Obtain an API Key

In order to use the Team-One REST API you must obtain an API Key or client_id for your application.

To obtain a client_id, send an email to the address apiteam@team-one.com with the subject "API Key".

You will receive an email that assigns two values:

  • A client_id, such as lsJLcwxUyll0p, which identifies your application to the Team-One API. The client_id is like a username--unique to your application but not necessarily a secret.

  • A client_secret, such as MkalkvoRGBZP1O, which authenticates your application to the Team-One API. The client_secret is like a password--it should remain a "shared secret" between Team-One and your application.

You'll use the client_id and client_secret values in order to obtain an access token that allows your application to access Team-One on behalf of an end-user, as described below.


Obtain an Authorization Code

An authorization code is proof that a given end-user has authorized your application to act on his or her behalf.

To obtain an authorization code, the end-user must log-in to Team-One and grant your application access.

To achieve this, direct the end-user to the path /auth/oauth2/authorization passing the following query string parameters:

  • response_type - following the OAuth2 specification this must be the value code.

  • client_id - the "API Key" assigned to your application.

  • scope - a comma-delimited list of the scopes your application is requesting access to, e.g., read,write.

  • redirect_uri - where to return the user to after authorization (passing the assigned authorization token back to your application as a query string parameter named code).

For example, let's assume that:

  1. Your application has been assigned the client_id lsJLcwxUyll0p.

  2. You'd like to obtain read and write access to the user's account.

  3. Your application is hosted at the domain https://example.com.

  4. Your application will use the path /oauth/callback to receive the authorization code.

Your application must then direct the user to the URL:

https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=code&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback

For example, you might provide the user with a direct link in your HTML code:

<a href="https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=code&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback">Link to Team-One Account</a>

or your server might redirect the user to Team-One by returning a HTTP 302 response:

HTTP/1.1 302 Found
Location: https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=code&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback

The end-user will be presented with a form by which she can authorize your application to access her Team-One account. (Or more specifically, access the Team-One scopes enumerated in the query string.)

After a succesful authorization, Team-One will redirect the user's browser back to the redirect_uri you provided, with the authorization code added a query string parameter named code.

https://example.com/oauth/callback?code=h4iu8zs29zy9cnmi840ub5bete3o9a4i

Make a note of the returned authorization code. (In the example above it is h4iu8zs29zy9cnmi840ub5bete3o9a4i.) You'll use it below to obtain an access token which ultimately provides access to the end-user's account.


Obtain an Access Token and Refresh Token

An access token is a credential that gives your application (temporary) access to an end-user's Team-One account.

A refresh token is a credential that allows your application to obtain a new access token when the current one becomes stale.

Given an authorization code (and the client_id and client_secret values assigned to your application) you can obtain an access token and an optional refresh-token by submitting a server-to-server request that includes all three values.

Request

Specifically, you must submit an HTTP POST to the path /auth/oauth2/access, posting a JSON document with the following attributes:

  • code - the authorization code created for the end-user and your application.

  • client_id - the client_id value assigned to your application.

  • client_secret - the client_secret value assigned to your application.

  • grant_type - following the OAuth2 specification, this must be the value authorization_code.

POST /rest/auth/oauth2/access HTTP/1.1
Host: app.intellinote.net
Content-Type: application/json
{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}
curl -H "Content-Type: application/json" \
     -X POST "https://app.intellinote.net/rest/auth/oauth2/access" \
     -d '{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}'
request = require "request" # https://www.npmjs.org/package/request
headers = "Content-Type": "application/json"
url     = "https://app.intellinote.net/rest/auth/oauth2/access"
payload = '{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}'

console.log "REQUEST: POST #{url}"
request.get url, {body:payload, headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request = require("request"); // https://www.npmjs.org/package/request
var headers = { "Content-Type": "application/json" };
var url     = "https://app.intellinote.net/rest/auth/oauth2/access";
var payload = '{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}';

console.log("REQUEST: POST "+ url);
request.post( url, {body:payload,headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/auth/oauth2/access";

    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpPost request = new HttpPost(url);
      StringEntity payload = new StringEntity('{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}');
      payload.setContentType("application/json");
      request.setEntity(payload);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/auth/oauth2/access"
puts "REQUEST: #{url}"
uri = URI.parse(url)

payload = '{"code":"h4iu8zs29zy9cnmi840ub5bete3o9a4i","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"authorization_code"}'

http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path,initheader = {'Content-Type'=>'application/json'})

req.body = payload

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
# Python example not available. Please try another language.
// C# example not available. Please try another language.
// PHP example not available. Please try another language.

Response

If successful, the Team-One server will return a JSON document containing the refresh_token assigned to your application and an active access_token that be used immediately for access.

HTTP/1.1 200 OK
Content-Type: application/json

{
  "refresh_token":"a29cf572ccdb7924d2c35ca95753f233",
  "access_token":"9m74lrwlcubu766rbmkqp2srche8w7b9"
}

You may then use the access token to submit requests to the Team-One API on behalf of the end-user.

Note that for security reasons, the access token value is only valid for a short time. If you submit an API request with a "stale" access token, the server will respond with an HTTP 401 ("Unauthorized") status. This indicates that you must use the refresh token to obtain a new access token, as described below.


Use Refresh Token to replace a stale Access Token

As noted, your access token will eventually time-out.

When this happens, you will start to recieve 401 (Authentication Required) responses from the server. This is your cue that it is time to refresh the access token.

Given an refresh token (and the client_id and client_secret values assigned to your application) you can obtain an access token (and an optionally, a replacement refresh-token) by submitting a server-to-server request that includes all three values.

Request

Specifically, you must submit an HTTP POST to the path /auth/oauth2/access, posting a JSON document with the following attributes:

  • token - the refresh token created for the end-user and your application.

  • client_id - the client_id value assigned to your application.

  • client_secret - the client_secret value assigned to your application.

  • grant_type - following the OAuth2 specification, this must be the value refresh_token.

POST /rest/auth/oauth2/access HTTP/1.1
Host: app.intellinote.net
Content-Type: application/json
{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}
curl -H "Content-Type: application/json" \
     -X POST "https://app.intellinote.net/rest/auth/oauth2/access" \
     -d '{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}'
request = require "request" # https://www.npmjs.org/package/request
headers = "Content-Type": "application/json"
url     = "https://app.intellinote.net/rest/auth/oauth2/access"
payload = '{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}'

console.log "REQUEST: POST #{url}"
request.get url, {body:payload, headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request = require("request"); // https://www.npmjs.org/package/request
var headers = { "Content-Type": "application/json" };
var url     = "https://app.intellinote.net/rest/auth/oauth2/access";
var payload = '{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}';

console.log("REQUEST: POST "+ url);
request.post( url, {body:payload,headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/auth/oauth2/access";

    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpPost request = new HttpPost(url);
      StringEntity payload = new StringEntity('{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}');
      payload.setContentType("application/json");
      request.setEntity(payload);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/auth/oauth2/access"
puts "REQUEST: #{url}"
uri = URI.parse(url)

payload = '{"token":"a29cf572ccdb7924d2c35ca95753f233","client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"refresh_token"}'

http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path,initheader = {'Content-Type'=>'application/json'})

req.body = payload

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
# Python example not available. Please try another language.
// C# example not available. Please try another language.
// PHP example not available. Please try another language.

Response

If successful, the Team-One server will return a JSON document containing an active access_token that be used immediately for access to the end-user's account.

The server may also return a new refresh token value. In that case you should make a note of the new refresh token, since the old one will not work any more.

HTTP/1.1 200 OK
Content-Type: application/json

{
  "refresh_token":"a29cf572ccdb7924d2c35ca95753f233",
  "access_token":"274ab5e925e4a654a94bd935844c71c6"
}

Obtain an Access Token using the Implicit Workflow

The OAuth2 implicit workflow is an alternative to the authorization-token-based process described above.

In the implicit workflow no persistent refresh token is provided. The end-user must authenticate to the Team-One service (and if necessary, authorize your application's access) every time an access token is needed.

The implicit workflow is most suitable for client-side (browser or mobile-device based) applications that (a) do not have a (secure) server-side component at which the client_secret value can be stored and from which the server-to-server request is submitted, and (b) for which the end-user will be actively using whenever the application needs to invoke the Team-One API.

In the implicit workflow the access token is both requested and delivered by URLs exchanged between applications by re-directing the end-user's browser.

The process starts by sending the end-user to the to the path /auth/oauth2/authorization passing the following query string parameters:

  • response_type - following the OAuth2 specification this must be the value token.

  • client_id - the "API Key" assigned to your application.

  • scope - a comma-delimited list of the scopes your application is requesting access to, e.g., read,write.

  • redirect_uri - where to return the user to after authorization (passing the assigned access token back to your application as a query string parameter named token).

For example, let's assume that:

  1. Your application has been assigned the client_id lsJLcwxUyll0p.

  2. You'd like to obtain read and write access to the user's account.

  3. Your application is hosted at the domain https://example.com.

  4. Your application will use the path /oauth/callback to receive the access token.

Your application must then direct the user to the URL:

https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=token&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback

For example, you might provide the user with a direct link in your HTML code:

<a href="https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=token&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback">Link to Team-One Account</a>

or your server might redirect the user to Team-One by returning a HTTP 302 response:

HTTP/1.1 302 Found
Location: https://app.intellinote.net/rest/auth/oauth2/authorization?response_type=token&client_id=lsJLcwxUyll0p&scope=read,write&redirect_uri=https://example.com/oauth/callback

The end-user must authenticate and (if she hasn't done this already) is presented with a form by which she can authorize your application to access her Team-One account. (Or more specifically, access the Team-One scopes enumerated in the query string.)

After a succesful authorization, Team-One will redirect the user's browser back to the redirect_uri you provided, with the access token added a query string parameter named token.

https://example.com/oauth/callback?token=9m74lrwlcubu766rbmkqp2srche8w7b9

You may then use the access token to submit requests to the Team-One API on behalf of the end-user.

Note that for security reasons, the access token value is only valid for a short time. If you submit an API request with a "stale" access token, the server will respond with an HTTP 401 ("Unauthorized") status. This indicates that you must re-submit the request above to "refresh" the token.


Perform a userless (application-level) log-in

Some Team-One API methods can be invoked outside of any specific "user context".

For example an application can create a new user record (via POST /user) without being authorized for access to any existing user's account.

If your application has been authorized (by Team-One) to do so, it can peform a type of "user-less" OAuth2 authentication known as a "client_credentials" grant. This "userless" application log-in generates an access token and refresh token like any other OAuth2 authorization process. The resulting access token will allow the application to interact with the Team-One API on its own behalf--independent of any user accounts.

The process for obtaining an access token via the client_credentials grant is very similiar to the process used to obtain an access token using the authorization_code and refresh_token grant types.

Request

Specifically, you must submit an HTTP POST to the path /auth/oauth2/access, posting a JSON document with the following attributes:

  • client_id - the client_id value assigned to your application.

  • client_secret - the client_secret value assigned to your application.

  • grant_type - following the OAuth2 specification, this must be the value client_credentials.

POST /rest/auth/oauth2/access HTTP/1.1
Host: app.intellinote.net
Content-Type: application/json
{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}
curl -H "Content-Type: application/json" \
     -X POST "https://app.intellinote.net/rest/auth/oauth2/access" \
     -d '{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}'
request = require "request" # https://www.npmjs.org/package/request
headers = "Content-Type": "application/json"
url     = "https://app.intellinote.net/rest/auth/oauth2/access"
payload = '{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}'

console.log "REQUEST: POST #{url}"
request.get url, {body:payload, headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request = require("request"); // https://www.npmjs.org/package/request
var headers = { "Content-Type": "application/json" };
var url     = "https://app.intellinote.net/rest/auth/oauth2/access";
var payload = '{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}';

console.log("REQUEST: POST "+ url);
request.post( url, {body:payload,headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/auth/oauth2/access";

    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpPost request = new HttpPost(url);
      StringEntity payload = new StringEntity('{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}');
      payload.setContentType("application/json");
      request.setEntity(payload);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/auth/oauth2/access"
puts "REQUEST: #{url}"
uri = URI.parse(url)

payload = '{"client_id":"lsJLcwxUyll0p","client_secret":"MkalkvoRGBZP1O","grant_type":"client_credentials"}'

http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path,initheader = {'Content-Type'=>'application/json'})

req.body = payload

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
# Python example not available. Please try another language.
// C# example not available. Please try another language.
// PHP example not available. Please try another language.

Response

If successful, the Team-One server will return a JSON document containing the refresh_token assigned to your application and an active access_token that be used immediately for access.

HTTP/1.1 200 OK
Content-Type: application/json

{
  "refresh_token":"a29cf572ccdb7924d2c35ca95753f233",
  "access_token":"9m74lrwlcubu766rbmkqp2srche8w7b9"
}

You may then use the access token to submit requests to the Team-One API.

Note that for security reasons, the access token value is only valid for a short time. If you submit an API request with a "stale" access token, the server will respond with an HTTP 401 ("Unauthorized") status. This indicates that you must use the refresh token to obtain a new access token, as described above.


List Organizations

With an active access_token you can submit an HTTP GET request to the path /v2.0/orgs to obtain a list of organizations the end-user belongs to.

Request

GET /rest/v2.0/orgs HTTP/1.1
Host: app.intellinote.net
Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9
curl -H "Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9" \
     "https://app.intellinote.net/rest/v2.0/orgs"
request      = require "request" # https://www.npmjs.org/package/request
access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9"
headers      = Authorization: "Bearer #{access_token}"
url          = "https://app.intellinote.net" +
               "/rest/v2.0/orgs"

console.log "REQUEST: GET #{url}"
request.get url, {headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request      = require("request"); // https://www.npmjs.org/package/request
var access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
var headers      = { Authorization: "Bearer " + access_token };
var url          = "https://app.intellinote.net" +
                   "/rest/v2.0/orgs";

console.log("REQUEST: GET "+ url);
request.get( url, {headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/v2.0/orgs";
    String access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpGet request = new HttpGet(url);
      request.setHeader("Authorization","Bearer "+access_token);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/v2.0/orgs"
puts "REQUEST: #{url}"
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req["Authorization"] ="Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9"

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
import httplib2 as http
import json
try:
    from urlparse import urlparse
except ImportError:
    from urllib.parse import urlparse

url = 'https://app.intellinote.net/rest/v2.0/orgs'
headers = { 'Authorization': 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9' }

print 'REQUEST: {}'.format(url)
target = urlparse(url)
method = 'GET'
body = ''

h = http.Http()
response, content = h.request( target.geturl(), method, body, headers )

print 'RESPONSE: {}'.format(response.status)
print json.loads(content)
using System;
using System.Net;
using ServiceStack.Text;
using System.Text;
using System.IO;

string url = 'https://app.intellinote.net" +
             "/rest/v2.0/orgs';
string authorization = 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9';
string responseBody = null;

Console.WriteLine("REQUEST");

var request = (HttpWebRequest) WebRequest.Create(url);
request.Method = "GET";
request.Headers.Add(HttpRequestHeader.Authorization, authorization);

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = new StreamReader(response.GetResponseStream()))
{
    responseBody = responseStream.ReadToEnd();
}
Console.WriteLine("RESPONSE");
Console.WriteLine(responseBody);
$url = 'https://app.intellinote.net'
       .'/v2.0/orgs';
$access_token = '9m74lrwlcubu766rbmkqp2srche8w7b9';

echo 'REQUEST '.$url

$curl = curl_init();
curl_setopt($crl, CURLOPT_URL, $url);
$header = array();
$header[] = 'Authorization: Bearer '.access_token;
curl_setopt($crl, CURLOPT_HTTPHEADER, $header);

$status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$result = curl_exec ($curl);

echo 'RESPONSE '.$status_code
echo $result

curl_close ($curl);

Response

The list of organizations is returned as a JSON document within the body of the HTTP response.

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "org_id":251,
    "name":"Example Org 1"
  },
  {
    "org_id":319,
    "name":"Example Org 2"
  }
]

List Workspaces

With an active access_token you can submit an HTTP GET request to the path /v2.0/org/[ORG_ID]/workspaces to obtain a list of workspaces within the specified organization that the end-user has access to. (Where [ORG_ID] is a valid organization identifier.)

Request

GET /rest/v2.0/orgs/251/workspaces HTTP/1.1
Host: app.intellinote.net
Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9
curl -H "Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9" \
     "https://app.intellinote.net/rest/v2.0/orgs/251/workspaces"
request      = require "request" # https://www.npmjs.org/package/request
access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9"
headers      = Authorization: "Bearer #{access_token}"
url          = "https://app.intellinote.net" +
               "/rest/v2.0/orgs/251/workspaces"

console.log "REQUEST: GET #{url}"
request.get url, {headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request      = require("request"); // https://www.npmjs.org/package/request
var access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
var headers      = { Authorization: "Bearer " + access_token };
var url          = "https://app.intellinote.net" +
                   "/rest/v2.0/orgs/251/workspaces";

console.log("REQUEST: GET "+ url);
request.get( url, {headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/v2.0/orgs/251/workspaces";
    String access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpGet request = new HttpGet(url);
      request.setHeader("Authorization","Bearer "+access_token);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/v2.0/orgs/251/workspaces"
puts "REQUEST: #{url}"
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req["Authorization"] ="Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9"

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
import httplib2 as http
import json
try:
    from urlparse import urlparse
except ImportError:
    from urllib.parse import urlparse

url = 'https://app.intellinote.net/rest/v2.0/orgs/251/workspaces'
headers = { 'Authorization': 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9' }

print 'REQUEST: {}'.format(url)
target = urlparse(url)
method = 'GET'
body = ''

h = http.Http()
response, content = h.request( target.geturl(), method, body, headers )

print 'RESPONSE: {}'.format(response.status)
print json.loads(content)
using System;
using System.Net;
using ServiceStack.Text;
using System.Text;
using System.IO;

string url = 'https://app.intellinote.net" +
             "/rest/v2.0/orgs/251/workspaces';
string authorization = 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9';
string responseBody = null;

Console.WriteLine("REQUEST");

var request = (HttpWebRequest) WebRequest.Create(url);
request.Method = "GET";
request.Headers.Add(HttpRequestHeader.Authorization, authorization);

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = new StreamReader(response.GetResponseStream()))
{
    responseBody = responseStream.ReadToEnd();
}
Console.WriteLine("RESPONSE");
Console.WriteLine(responseBody);
$url = 'https://app.intellinote.net'
       .'/v2.0/orgs/251/workspaces';
$access_token = '9m74lrwlcubu766rbmkqp2srche8w7b9';

echo 'REQUEST '.$url

$curl = curl_init();
curl_setopt($crl, CURLOPT_URL, $url);
$header = array();
$header[] = 'Authorization: Bearer '.access_token;
curl_setopt($crl, CURLOPT_HTTPHEADER, $header);

$status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$result = curl_exec ($curl);

echo 'RESPONSE '.$status_code
echo $result

curl_close ($curl);

Response

The list of workspaces is returned as a JSON document within the body of the HTTP response.

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "workspace_id": 862,
    "name": "My Private Notebooks"
  },
  {
    "workspace_id": 973,
    "name": "Sales Leads"
  },
  {
    "workspace_id": 1143,
    "name": "Project Foo"
  }
]

List Notes

With an active access_token you can submit an HTTP GET request to the path /v2.0/org/[ORG_ID]/workspace/[WORKSPACE_ID]/notes to obtain a list of notes (including tasks and discussions) that the end-user has access to within the specified workspace. (Where [WORKSPACE_ID] is a valid workspace identifier and [ORG_ID] is a valid organization identifier for the organization that contains the specified workspace.)

Request

The request may contain one of several query-string parameters that filter or otherwise determine the list of notes that are returned. In this case, we'll use note_type=NOTE to limit the response to true notes (as opposed to tasks or discussions).

GET /rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE HTTP/1.1
Host: app.intellinote.net
Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9
curl -H "Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9" \
     "https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE"
request      = require "request" # https://www.npmjs.org/package/request
access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9"
headers      = Authorization: "Bearer #{access_token}"
url          = "https://app.intellinote.net" +
               "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE"

console.log "REQUEST: GET #{url}"
request.get url, {headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request      = require("request"); // https://www.npmjs.org/package/request
var access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
var headers      = { Authorization: "Bearer " + access_token };
var url          = "https://app.intellinote.net" +
                   "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE";

console.log("REQUEST: GET "+ url);
request.get( url, {headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE";
    String access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpGet request = new HttpGet(url);
      request.setHeader("Authorization","Bearer "+access_token);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE"
puts "REQUEST: #{url}"
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req["Authorization"] ="Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9"

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
import httplib2 as http
import json
try:
    from urlparse import urlparse
except ImportError:
    from urllib.parse import urlparse

url = 'https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE'
headers = { 'Authorization': 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9' }

print 'REQUEST: {}'.format(url)
target = urlparse(url)
method = 'GET'
body = ''

h = http.Http()
response, content = h.request( target.geturl(), method, body, headers )

print 'RESPONSE: {}'.format(response.status)
print json.loads(content)
using System;
using System.Net;
using ServiceStack.Text;
using System.Text;
using System.IO;

string url = 'https://app.intellinote.net" +
             "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE';
string authorization = 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9';
string responseBody = null;

Console.WriteLine("REQUEST");

var request = (HttpWebRequest) WebRequest.Create(url);
request.Method = "GET";
request.Headers.Add(HttpRequestHeader.Authorization, authorization);

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = new StreamReader(response.GetResponseStream()))
{
    responseBody = responseStream.ReadToEnd();
}
Console.WriteLine("RESPONSE");
Console.WriteLine(responseBody);
$url = 'https://app.intellinote.net'
       .'/v2.0/orgs/251/workspace/1143/notes?note_type=NOTE';
$access_token = '9m74lrwlcubu766rbmkqp2srche8w7b9';

echo 'REQUEST '.$url

$curl = curl_init();
curl_setopt($crl, CURLOPT_URL, $url);
$header = array();
$header[] = 'Authorization: Bearer '.access_token;
curl_setopt($crl, CURLOPT_HTTPHEADER, $header);

$status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$result = curl_exec ($curl);

echo 'RESPONSE '.$status_code
echo $result

curl_close ($curl);

Response

The list of notes is returned as a JSON document within the body of the HTTP response.

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "note_id": 2248,
    "note_type": "NOTE",
    "title": "Lorem Ipsum",
    "body": "Vestibulum convallis a semper...dui euismod elit.",
    "state": "ACTIVE",
    "creator": {
      "user_id": "user4321",
      "given_name": "Jane",
      "family_name": "Doe"
    },
    "tags": [
      {
        "tag_id": 127,
        "name": "Work"
      },
      {
        "tag_id": 564,
        "name": "SampleTag"
      }
    ]
  },
  {
    "note_id": 412,
    "note_type": "NOTE",
    "title": "Accumsan Nisl",
    "body": "Cum sociis natoque penatibus et magnis dis parturient nascetur ridiculus mus.",
    "state": "ACTIVE",
    "creator": {
      "user_id": "user525",
      "given_name": "Finn",
      "family_name": "Sevastyan"
    },
    "tags": [
      {
        "tag_id": 564,
        "name": "to-review"
      }
    ]
  }
]

List Incomplete Tasks Assigned to a User

With an active access_token you can submit an HTTP GET request to the path /v2.0/org/[ORG_ID]/workspace/[WORKSPACE_ID]/notes to obtain a list of notes (including tasks and discussions) that the end-user has access to within the specified workspace. (Where [WORKSPACE_ID] is a valid workspace identifier and [ORG_ID] is a valid organization identifier for the organization that contains the specified workspace.)

Request

The request may contain one of several query-string parameters that filter or otherwise determine the list of notes that are returned. In this case, we'll use:

  • note_type=TASK to limit the response to tasks (as opposed to notes or discussions),
  • complete=false to limit the response to tasks that haven't been completed yet, and
  • assignee==user525 to limit the response to the tasks assigned to a specific user (where user525 is this user's user_id value).

(See the API documentation for a complete list of and additional information on the supported parameters.)

Request

GET /rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525 HTTP/1.1
Host: app.intellinote.net
Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9
curl -H "Authorization: Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9" \
     "https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525"
request      = require "request" # https://www.npmjs.org/package/request
access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9"
headers      = Authorization: "Bearer #{access_token}"
url          = "https://app.intellinote.net" +
               "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525"

console.log "REQUEST: GET #{url}"
request.get url, {headers:headers,json:true}, (err,response,body)->
  if err?
    console.error 'Encountered an error', err
    process.exit(2)
  else
    console.log "RESPONSE: Status #response.statusCode}"
    if body?
      console.log JSON.stringify(body,null,2)
var request      = require("request"); // https://www.npmjs.org/package/request
var access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
var headers      = { Authorization: "Bearer " + access_token };
var url          = "https://app.intellinote.net" +
                   "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525";

console.log("REQUEST: GET "+ url);
request.get( url, {headers:headers,json:true}, function(err,response,body) {
  if(err) {
    console.error("Encountered an error",err);
    process.exit(2);
  } else {
    console.log("RESPONSE: Status "+ response.statusCode);
    if(body) {
      console.log(JSON.stringify(body,null,2));
    }
  }
});
import java.io.*;
import org.apache.http.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*
import org.apache.http.impl.client.*;
import org.apache.http.entity.*;

public class RESTClient {
  public static void main(String[] args) {
    String url          = "https://app.intellinote.net" +
                          "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525";
    String access_token = "9m74lrwlcubu766rbmkqp2srche8w7b9";
    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpGet request = new HttpGet(url);
      request.setHeader("Authorization","Bearer "+access_token);

      System.out.println("REQUEST: " + url);
      HttpResponse response = httpClient.execute(request);

      System.out.println("RESPONSE: " +response.getStatusLine());

      HttpEntity entity = httpResponse.getEntity();
      if (entity != null) {
        byte[] buffer = new byte[1024];
        InputStream inputStream = entity.getContent();
        try {
          int bytesRead = 0;
          BufferedInputStream bis = new BufferedInputStream(inputStream);
          while ((bytesRead = bis.read(buffer)) != -1) {
            String chunk = new String(buffer, 0, bytesRead);
            System.out.println(chunk);
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          try { inputStream.close(); } catch (Exception ignore) {}
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
}
require "net/http"
require "uri"
require "json"

url = "https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525"
puts "REQUEST: #{url}"
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req["Authorization"] ="Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9"

response = http.request(req)
puts "RESPONSE: #{response.status}"
puts JSON.pretty_generate(JSON.parse(response.body))
import httplib2 as http
import json
try:
    from urlparse import urlparse
except ImportError:
    from urllib.parse import urlparse

url = 'https://app.intellinote.net/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525'
headers = { 'Authorization': 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9' }

print 'REQUEST: {}'.format(url)
target = urlparse(url)
method = 'GET'
body = ''

h = http.Http()
response, content = h.request( target.geturl(), method, body, headers )

print 'RESPONSE: {}'.format(response.status)
print json.loads(content)
using System;
using System.Net;
using ServiceStack.Text;
using System.Text;
using System.IO;

string url = 'https://app.intellinote.net" +
             "/rest/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&complete=false&assignee=user525';
string authorization = 'Bearer 9m74lrwlcubu766rbmkqp2srche8w7b9';
string responseBody = null;

Console.WriteLine("REQUEST");

var request = (HttpWebRequest) WebRequest.Create(url);
request.Method = "GET";
request.Headers.Add(HttpRequestHeader.Authorization, authorization);

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = new StreamReader(response.GetResponseStream()))
{
    responseBody = responseStream.ReadToEnd();
}
Console.WriteLine("RESPONSE");
Console.WriteLine(responseBody);
$url = 'https://app.intellinote.net'
       .'/v2.0/orgs/251/workspace/1143/notes?note_type=TASK&amp;complete=false&amp;assignee=user525';
$access_token = '9m74lrwlcubu766rbmkqp2srche8w7b9';

echo 'REQUEST '.$url

$curl = curl_init();
curl_setopt($crl, CURLOPT_URL, $url);
$header = array();
$header[] = 'Authorization: Bearer '.access_token;
curl_setopt($crl, CURLOPT_HTTPHEADER, $header);

$status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$result = curl_exec ($curl);

echo 'RESPONSE '.$status_code
echo $result

curl_close ($curl);

Response

The list of tasks is returned as a JSON document within the body of the HTTP response.

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "note_id": 1376,
    "note_type": "TASK",
    "title": "Review Contract",
    "body": "Finn, please review the latest draft of this contract.",
    "state": "ACTIVE",
    "creator": {
      "user_id": "user4321",
      "given_name": "Jane",
      "family_name": "Doe"
    },
    "assignee": {
      "user_id": "user525",
      "given_name": "Finn",
      "family_name": "Sevastyan"
    },
    "tags": [
      {
        "tag_id": 564,
        "name": "to-review"
      }
    ],
    "due":"2013-11-19T06:09:07.435Z"
  },
  {
    "note_id": 8675,
    "note_type": "TASK",
    "title": "Taskum Lorem",
    "body": "Mauris ac <strong>felis vel velit</strong> tristique imperdiet.",
    "state": "ACTIVE",
    "creator": {
      "user_id": "user525",
      "given_name": "Finn",
      "family_name": "Sevastyan"
    },
    "assignee": {
      "user_id": "user525",
      "given_name": "Finn",
      "family_name": "Sevastyan"
    }
  }
]