Speckle 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.

Speckle is an open source design/AEC data communication protocol and platform.

Base URLs:

https://hestia.speckle.works/api

Email: SpeckleWorks Web: SpeckleWorks License: MIT

Authentication

API Key (JWT)
- Parameter Name: Authorization, in: header. A JWT token acquired from the /accounts/login endpoint.

Accounts

UserRegister

Code samples

# You can also use wget
curl -X POST https://hestia.speckle.works/api/accounts/register \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/accounts/register HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts/register',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/accounts/register',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/accounts/register', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/accounts/register", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /accounts/register

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

Name	In	Type	Required	Description
body	body	User	true	The user object to register.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/accounts/login \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/accounts/login HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts/login',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/accounts/login',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/accounts/login', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/accounts/login", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /accounts/login

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

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

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/accounts/search \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/accounts/search HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts/search',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/accounts/search',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/accounts/search', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/accounts/search", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /accounts/search

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

Name	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

200 Response

{
  "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 https://hestia.speckle.works/api/accounts \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/accounts HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/accounts',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/accounts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/accounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /accounts

Gets your profile.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/accounts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/accounts HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts',
  method: 'put',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/accounts',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/accounts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/accounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /accounts

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

Name	In	Type	Required	Description
body	body	User	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/accounts/{userId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/accounts/{userId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/accounts/{userId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/accounts/{userId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/accounts/{userId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/accounts/{userId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /accounts/{userId}

Gets a user's profile.

Parameters

Name	In	Type	Required	Description
userId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/clients \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/clients HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/clients',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /clients

Gets a user's profile.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/clients \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/clients HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/clients',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /clients

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

Name	In	Type	Required	Description
body	body	AppClient	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/clients/{clientId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/clients/{clientId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/clients/{clientId}',
  method: 'put',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/clients/{clientId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /clients/{clientId}

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

Name	In	Type	Required	Description
clientId	path	string	true	none
body	body	AppClient	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/clients/{clientId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/clients/{clientId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/clients/{clientId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/clients/{clientId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /clients/{clientId}

Get a client

Parameters

Name	In	Type	Required	Description
clientId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/clients/{clientId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE https://hestia.speckle.works/api/clients/{clientId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/clients/{clientId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.delete 'https://hestia.speckle.works/api/clients/{clientId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://hestia.speckle.works/api/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hestia.speckle.works/api/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /clients/{clientId}

Deletes a client

Parameters

Name	In	Type	Required	Description
clientId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/projects \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/projects HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/projects',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/projects',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/projects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/projects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /projects

Gets a user's projects.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/projects \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/projects HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/projects',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/projects',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/projects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/projects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /projects

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

Name	In	Type	Required	Description
body	body	Project	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/projects/{projectId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/projects/{projectId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/projects/{projectId}',
  method: 'put',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/projects/{projectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/projects/{projectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/projects/{projectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /projects/{projectId}

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

Name	In	Type	Required	Description
projectId	path	string	true	none
body	body	Project	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/projects/{projectId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/projects/{projectId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/projects/{projectId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/projects/{projectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/projects/{projectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/projects/{projectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /projects/{projectId}

Get a project

Parameters

Name	In	Type	Required	Description
projectId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/projects/{projectId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE https://hestia.speckle.works/api/projects/{projectId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/projects/{projectId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.delete 'https://hestia.speckle.works/api/projects/{projectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://hestia.speckle.works/api/projects/{projectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hestia.speckle.works/api/projects/{projectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /projects/{projectId}

Deletes a project

Parameters

Name	In	Type	Required	Description
projectId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/comments/{resourceType}/{resourceId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/comments/{resourceType}/{resourceId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /comments/{resourceType}/{resourceId}

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

Name	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	none

Enumerated Values

Parameter	Value
resourceType	stream
resourceType	object
resourceType	project
resourceType	comment

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/comments/{resourceType}/{resourceId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/comments/{resourceType}/{resourceId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/comments/{resourceType}/{resourceId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /comments/{resourceType}/{resourceId}

Gets the comments from a resource.

Parameters

Name	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

200 Response

{
  "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 https://hestia.speckle.works/api/comments/{commentId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/comments/{commentId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/comments/{commentId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/comments/{commentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/comments/{commentId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/comments/{commentId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /comments/{commentId}

Gets a specific comment.

Parameters

Name	In	Type	Required	Description
commentId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/comments/{commentId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/comments/{commentId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/comments/{commentId}',
  method: 'put',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/comments/{commentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/comments/{commentId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/comments/{commentId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /comments/{commentId}

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

Name	In	Type	Required	Description
commentId	path	string	true	none
body	body	Comment	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/comments/{commentId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE https://hestia.speckle.works/api/comments/{commentId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/comments/{commentId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.delete 'https://hestia.speckle.works/api/comments/{commentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://hestia.speckle.works/api/comments/{commentId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hestia.speckle.works/api/comments/{commentId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /comments/{commentId}

Deletes a specific comment.

Parameters

Name	In	Type	Required	Description
commentId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/streams HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/streams',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/streams', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/streams", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /streams

Gets a user's streams.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/streams HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams',
  method: 'post',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/streams',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/streams', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/streams", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /streams

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

Name	In	Type	Required	Description
body	body	SpeckleStream	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams/{streamId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/streams/{streamId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/streams/{streamId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/streams/{streamId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/streams/{streamId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /streams/{streamId}

Gets a specific stream.

Parameters

Name	In	Type	Required	Description
streamId	path	string	true	none
query	query	string	false	Specifiy which fields to retrieve, ie `?fields=layers,baseProperties`.

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams/{streamId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/streams/{streamId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}',
  method: 'put',

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

const fetch = 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',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/streams/{streamId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/streams/{streamId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/streams/{streamId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /streams/{streamId}

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

Name	In	Type	Required	Description
streamId	path	string	true	none
body	body	SpeckleStream	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams/{streamId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE https://hestia.speckle.works/api/streams/{streamId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.delete 'https://hestia.speckle.works/api/streams/{streamId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://hestia.speckle.works/api/streams/{streamId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hestia.speckle.works/api/streams/{streamId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /streams/{streamId}

Deletes a specific stream.

Parameters

Name	In	Type	Required	Description
streamId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams/{streamId}/objects \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/streams/{streamId}/objects HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}/objects',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/streams/{streamId}/objects',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/streams/{streamId}/objects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/streams/{streamId}/objects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /streams/{streamId}/objects

Gets stream objects.

Parameters

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

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/streams/{streamId}/clone \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/streams/{streamId}/clone HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}/clone',
  method: 'post',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/streams/{streamId}/clone',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/streams/{streamId}/clone', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/streams/{streamId}/clone", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /streams/{streamId}/clone

Clones a stream.

Parameters

Name	In	Type	Required	Description
streamId	path	string	true	none

Example responses

200 Response

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

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 https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/streams/{streamId}/diff/{otherStreamId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

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

Diffs two streams (objects and layers).

Parameters

Name	In	Type	Required	Description
streamId	path	string	true	none
otherStreamId	path	string	true	none

Example responses

200 Response

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

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 https://hestia.speckle.works/api/objects \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/objects HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects',
  method: 'post',

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

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

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/objects',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/objects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/objects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /objects

Create one or more objects

Body parameter

[
  {}
]

Parameters

Name	In	Type	Required	Description
body	body	array[object]	false	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/objects/{objectId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/objects/{objectId} HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects/{objectId}',
  method: 'put',

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

const fetch = 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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/objects/{objectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/objects/{objectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/objects/{objectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /objects/{objectId}

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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}

Parameters

Name	In	Type	Required	Description
objectId	path	string	true	none
body	body	SpeckleObject	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/objects/{objectId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET https://hestia.speckle.works/api/objects/{objectId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects/{objectId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'https://hestia.speckle.works/api/objects/{objectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://hestia.speckle.works/api/objects/{objectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://hestia.speckle.works/api/objects/{objectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /objects/{objectId}

Get a object

Parameters

Name	In	Type	Required	Description
objectId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/objects/{objectId} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE https://hestia.speckle.works/api/objects/{objectId} HTTP/1.1
Host: hestia.speckle.works
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects/{objectId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.delete 'https://hestia.speckle.works/api/objects/{objectId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://hestia.speckle.works/api/objects/{objectId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://hestia.speckle.works/api/objects/{objectId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /objects/{objectId}

Deletes an object

Parameters

Name	In	Type	Required	Description
objectId	path	string	true	none

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/objects/{objectId}/properties \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT https://hestia.speckle.works/api/objects/{objectId}/properties HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects/{objectId}/properties',
  method: 'put',

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

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

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'https://hestia.speckle.works/api/objects/{objectId}/properties',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://hestia.speckle.works/api/objects/{objectId}/properties', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://hestia.speckle.works/api/objects/{objectId}/properties", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /objects/{objectId}/properties

Does a merge update of the object's properties.

Body parameter

{}

Parameters

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

Example responses

200 Response

{
  "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 https://hestia.speckle.works/api/objects/getbulk \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST https://hestia.speckle.works/api/objects/getbulk HTTP/1.1
Host: hestia.speckle.works
Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: 'https://hestia.speckle.works/api/objects/getbulk',
  method: 'post',

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

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

};

fetch('https://hestia.speckle.works/api/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',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'https://hestia.speckle.works/api/objects/getbulk',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://hestia.speckle.works/api/objects/getbulk', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://hestia.speckle.works/api/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://hestia.speckle.works/api/objects/getbulk", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /objects/getbulk

Gets a load of objects

Body parameter

[
  "string"
]

Parameters

Name	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

200 Response

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

Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
owner	string	false	none	none
private	boolean	false	none	none
anonymousComments	boolean	false	none	none
canRead	[string]	false	none	none
canWrite	[string]	false	none	none
comments	[string]	false	none	An array of comment ids.
deleted	boolean	false	none	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": []
}

Describes a user.

Properties

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

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
}

A speckle client.

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResourceBase	false	none	Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» _id	string	false	none	Database uuid.
» role	string	false	none	Either Sender, Receiver or anything else you can think of.
» documentGuid	string	false	none	none
» documentName	string	false	none	none
» documentType	string	false	none	none
» documentLocation	string	false	none	none
» streamId	string	false	none	The streamId that this client is attached to.
» online	boolean	false	none	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": []
}

A project contains a group of streams and users.

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResourceBase	false	none	Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

and

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

Comment

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

A comment/issue.

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResourceBase	false	none	Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

and

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

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": []
}

A stream is essentially a collection of objects, with added properties.

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResourceBase	false	none	Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» streamId	string	false	none	The stream's short id.
» name	string	false	none	The data stream's name
» objects	[SpeckleObject]	false	none	An array of SpeckleObject ids.
» layers	[Layer]	false	none	An array of speckle layers.
» baseProperties	object	false	none	Units, tolerances, etc.
» globalMeasures	object	false	none	Any performance measures can go in here.
» isComputedResult	boolean	false	none	none
» viewerLayers	[object]	false	none	none
» parent	string	false	none	If this stream is a child, the parent's streamId.
» children	[string]	false	none	An array of the streamId of any children of this stream.
» ancestors	[string]	false	none	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": {}
}

Describes a speckle layer. To assign objects to a speckle layer, you'll need to start at objects[ layer.startIndex ] and finish at objects[ layer.startIndex + layer.objectCount ].

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	Layer's name
guid	string	false	none	Layer's guid (must be unique)
orderIndex	integer	false	none	Describes this layer's position in the list of layers.
startIndex	number	false	none	The index of the first object relative to the stream's objects array
objectCount	number	false	none	How many objects does this layer have.
topology	string	false	none	String describing the nested tree structure (GH centric).
properties	LayerProperties	false	none	Holds stream layer properties, mostly for displaying purposes. This object will be filled up with garbage from threejs and others, but below is a minimal schema.

LayerProperties

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

Holds stream layer properties, mostly for displaying purposes. This object will be filled up with garbage from threejs and others, but below is a minimal schema.

Properties

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

ResponseUser

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	User	false	none	Describes a user.
» resources	[User]	false	none	[Describes a user.]

ResponseBase

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

Properties

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

ResponseClient

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	AppClient	false	none	A speckle client.
» resources	[AppClient]	false	none	[A speckle client.]

ResponseProject

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	Project	false	none	A project contains a group of streams and users.
» resources	[Project]	false	none	[A project contains a group of streams and users.]

ResponseComment

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	Comment	false	none	A comment/issue.
» resources	[Comment]	false	none	[A comment/issue.]

ResponseStream

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	SpeckleStream	false	none	A stream is essentially a collection of objects, with added properties.
» resources	[SpeckleStream]	false	none	[A stream is essentially a collection of objects, with added properties.]

ResponseObject

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» resource	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.
» resources	[SpeckleObject]	false	none	[Base class that is inherited by all other Speckle objects.]

ResponseStreamClone

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» clone	SpeckleStream	false	none	A stream is essentially a collection of objects, with added properties.
» parent	SpeckleStream	false	none	A stream is essentially a collection of objects, with added properties.

ResponseStreamDiff

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

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResponseBase	false	none	none

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» objects	object	false	none	none
»» common	[string]	false	none	none
»» inA	[string]	false	none	none
»» inB	[string]	false	none	none
» layers	object	false	none	none
»» common	[Layer]	false	none	[Describes a speckle layer. To assign objects to a speckle layer, you'll need to start at `objects[ layer.startIndex ]` and finish at `objects[ layer.startIndex + layer.objectCount ]`.]
»» inA	[Layer]	false	none	[Describes a speckle layer. To assign objects to a speckle layer, you'll need to start at `objects[ layer.startIndex ]` and finish at `objects[ layer.startIndex + layer.objectCount ]`.]
»» inB	[Layer]	false	none	[Describes a speckle layer. To assign objects to a speckle layer, you'll need to start at `objects[ layer.startIndex ]` and finish at `objects[ layer.startIndex + layer.objectCount ]`.]

SpeckleObject

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

Base class that is inherited by all other Speckle objects.

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	ResourceBase	false	none	Base class that adds a set of simple properties related to authorisation and commenting to all applicable resources (not users).

and

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

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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "_type": "string",
  "assembly": "string"
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» _type	string	false	none	the original type of the object
» assembly	string	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none

SpeckleBoolean

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» value	boolean	false	none	none

SpeckleNumber

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» value	number	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": "string"
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» value	string	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "start": 0,
  "end": 0
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» start	number	false	none	none
» end	number	false	none	none

SpeckleInterval2d

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» U	SpeckleInterval	false	none	U interval.
» V	SpeckleInterval	false	none	V interval.

SpecklePoint

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» value	[number]	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» value	[number]	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "origin": {},
  "normal": {},
  "xdir": {},
  "ydir": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» origin	SpecklePoint	false	none	The origin of the plane.
» normal	SpeckleVector	false	none	The normal of the plane.
» xdir	SpeckleVector	false	none	The X axis of the plane.
» ydir	SpeckleVector	false	none	The Y axis of the plane.

SpeckleCircle

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleArc

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleEllipse

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpecklePolycurve

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» segments	[SpeckleObject]	false	none	[Base class that is inherited by all other Speckle objects.]
» domain	SpeckleInterval	false	none	none

SpeckleBox

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleLine

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpecklePolyline

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleCurve

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Curve",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "name": "string",
  "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	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleMesh

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» vertices	[number]	false	none	The mesh's vertices array, in a flat array (ie, `x1, y1, z1, x2, y2, ...`)
» faces	[number]	false	none	The faces array.
» colors	[number]	false	none	If any, the colours per vertex.
» textureCoordinates	[number]	false	none	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",
  "name": "string",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "rawData": {},
  "provenance": "string",
  "displayValue": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» type	any	false	none	none
» rawData	object	false	none	The brep's raw (serialisation) data.
» provenance	string	false	none	A short prefix of where the base64 comes from.
» displayValue	SpeckleMesh	false	none	Contains a speckle mesh representation of this brep.

SpeckleExtrusion

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» capped	boolean	false	none	none
» profile	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.
» pathStart	SpecklePoint	false	none	none
» pathEnd	SpecklePoint	false	none	none
» pathCurve	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

SpeckleAnnotation

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "name": "string",
  "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	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

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

SpeckleBlock

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

Properties

allOf - discriminator: SpeckleObject.type

Name	Type	Required	Restrictions	Description
anonymous	SpeckleObject	false	none	Base class that is inherited by all other Speckle objects.

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» blockName	string	false	none	the name of the block definition used to insert this block
» description	string	false	none	none
» objects	[SpeckleObject]	false	none	[Base class that is inherited by all other Speckle objects.]