NAV

Nucleus  Proton  Electron

curl java python ruby javascript

Introduction

Sandbox Base URL

https://sandbox.hydrogenplatform.com/nucleus/v1

Production Base URL

https://api.hydrogenplatform.com/nucleus/v1

The Hydrogen Nucleus API provides the digital infrastructure you will need to quickly build and scale your fintech application in savings, investing, wealth, insurance, and financial wellness. This includes the base functionality to authenticate, onboard clients and accounts, and store and process data which all other APIs in the Hydrogen Atom platform will utilize.

All Hydrogen APIs are built on REST principles, with resource oriented URLs and HTTP response codes. All API responses are returned in JSON format. Additional features of the API include filtering, pagination, and data caching.

We provide a free sandbox environment to test our APIs before going into production. Please sign up now to request your keys.

Authentication

API Authentication

After successful registration of your application, you will be provided a client_id and client_secret which will be used to identify your application when calling any Hydrogen API.

We require all API calls to be made over HTTPS connections.

OAuth2 Authorization

Hydrogen uses OAuth 2.0 to facilitate authorization on the API, an industry standard framework for authorization. Two standard type of flows are supported:

  1. Client Credentials
  2. Resource Owner Password Credentials

Client Credentials

The Client Credentials authorization flow consists of exchanging a client_id and client_secret for an access_token to be provided when making calls to the Hydrogen API. This type of authorization is used for the application to access resources about itself rather than a user.

Example Request

curl -X POST https://api.hydrogenplatform.com/authorization/v1/oauth/token?grant_type=client_credentials \
  -H "Authorization: Basic aHlkcm9nZW5faWQ6aHlkcm9nZW5fc2VjcmV0"
from __future__ import print_function
import time
import atom_api
from atom_api.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth
configuration = atom_api.Configuration()

# Set the environment (optional, defaults to sandbox)
# This changes the URL for requests (including OAuth) to [environment].hydrogenplatform.com
configuration.set_environment("sandbox")

# Method 1: Fetch and set access token with client_id and client_secret
configuration.access_token = configuration.get_oauth_token('MYCLIENTID', 'MYCLIENTSECRET')
# Method 2: Set access token using an existing token
configuration.access_token = 'MYACCESSTOKEN'
# Load the gem
require 'atom_api'

# Setup authorization
AtomApi.configure do |config|
  # Set the environment (optional, defaults to sandbox)
  # This changes the URL for requests (including OAuth) to [environment].hydrogenplatform.com
  config.set_environment("sandbox")

  # Configure OAuth2 access token for authorization: oauth
  # Method 1: Fetch and set access token with client_id and client_secret
  config.access_token = config.get_oauth_token('MYCLIENTID', 'MYCLIENTSECRET')
  # Method 2: Set access token using an existing token
  config.access_token = 'MYACCESSTOKEN'
end
// Import classes:
import atom_api.ApiClient;
import atom_api.ApiException;
import atom_api.Configuration;
import atom_api.auth.*;
import io.swagger.client.api.NucleusApi;

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Set the environment (optional, defaults to sandbox)
// This changes the URL for requests (including OAuth) to [environment].hydrogenplatform.com
defaultClient.setEnvironment("sandbox");

// Configure OAuth2 access token for authorization: oauth
OAuth oauth = (OAuth) defaultClient.getAuthentication("oauth");
// Method 1: Fetch and set access token with client_id and client_secret
String token = oauth.fetchAccessToken("MYCLIENTID", "MYCLIENTSECRET");
oauth.setAccessToken(token);
// Method 2: Set access token using an existing token
oauth.setAccessToken("YOUR ACCESS TOKEN");
var atom_api = require('hydrogen-atom-api');
var defaultClient = atom_api.ApiClient.instance;

// (Optional) Set the Atom environment you wish to use (defaults to sandbox)
// This changes the URL for requests to [environment].hydrogenplatform.com
defaultClient.basePath = "https://sandbox.hydrogenplatform.com";

// Configure OAuth2 access token for authorization: oauth
// Ensure the token is from the same environment as the defaultClient.basePath above
var oauth = defaultClient.authentications['oauth'];
oauth.accessToken = 'YOUR ACCESS TOKEN';

Example Response

{
  "access_token": "ac6b8213-2a77-4ecc-89fd-68c9f2aff256",
  "token_type": "bearer",
  "expires_in": 86400,
  "scope": "create read update delete",
  "apps": "nucleus,proton,electron"
}

All subsequent API calls will then be made like the following example:

curl -X GET https://api.hydrogenplatform.com/nucleus/v1/account \
-H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
try:
    # Get information for all accounts for all clients defined for your firm
    api_response = api_instance.get_accounts()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_accounts: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #Get information for all accounts for all clients defined for your firm
  result = api_instance.get_accounts()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_accounts: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountResponse result = apiInstance.getAccounts();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccounts");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccounts(opts, callback);

The client credentials flow is used by your application to obtain permission to act on its own behalf. A call will be made to our OAuth server to exchange your client_id, client_secret, and grant_type=client_credentials for an access_token, which can then be used to make calls to Hydrogen on behalf of the application.

HTTP REQUEST

POST /authorization/v1/oauth/token?grant_type=client_credentials

ARGUMENTS

Parameter Type Required Description
client_id string required Application id for identification, which will be given to you when you are onboarded
client_secret string required Application secret, which will be given to you only once when you are onboarded. Please keep this in a safe place
grant_type string required Must be set to client_credentials

RESPONSE

Field Description
access_token Token that will be used for all subsequent API calls
expires_in When the token expires in seconds and will need to be called again. Default is 86400 or 24 hours.
token_type Always will be bearer
scope The scope your user has been granted in the application
apps APIs to which the user has access. Possible values include nucleus, proton, electron, hydro, molecule, integration

Resource Owner Password Credentials

The Resource Owner Password Credentials authorization flow consists of exchanging a username and password specific to a user in addition to your client_id and client_secret for an access_token to be provided when making calls to the Hydrogen API. This type of authorization validates the username and password of a user and is used for the application to access resources about a user.

curl -X POST https://api.hydrogenplatform.com/authorization/v1/oauth/token?grant_type=password&username={username}&password={password} \
  -H "Authorization: Basic aHlkcm9nZW5faWQ6aHlkcm9nZW5fc2VjcmV0"

Example Response

{
  "access_token": "ac6b8213-2a77-4ecc-89fd-68c9f2aff256",
  "token_type": "bearer",
  "expires_in": 86400,
  "scope": "create read update delete",
  "apps": "nucleus,proton,electron",
  "jti": "6118a6c2-92fd-450f-ae1d-198150c0b579"
}

The resource owner password credentials flow, or password credentials flow, is used to identify specific users and act according to their permissions. A call will be made to our OAuth server to exchange your client_id and client_secret as well as the user’s username and password, and grant_type=password for a user-specific access_token, which can then be used to make calls to Hydrogen APIs.


HTTP REQUEST

POST /authorization/v1/oauth/token?grant_type=password&username={username}&password={password}

ARGUMENTS

Parameter Type Required Description
client_id string required Application id for identification, which will be given to you when you are onboarded
client_secret string required Application secret, which will be given to you only once when you are onboarded. Please keep this in a safe place
username string required User’s unique username for the application
password string required User’s unique password for the application
grant_type string required Must be set to password

RESPONSE

Field Description
access_token Token that will be used for all subsequent API calls
expires_in When the token expires in seconds and will need to be called again. Default is 86400 or 24 hours.
token_type Always will be bearer
scope N/A - this is embedded in the access_token returned
apps APIs to which the user has access. Possible values include nucleus, proton, electron, hydro, ion

Token Refresh

An access_token will need to be refreshed to continue being authorized for the app. Access tokens are short lived: 24 hours. The Client Credentials grant type doesn’t return a refresh token. When your access_token expires, the app has to simply request a new token which will invalidate the previous token. The token can be deserialized to determine how much longer it is valid.

Client Authentication

You may optionally wish to store user credentials such as usernames and passwords with Hydrogen to permission applications that require a user login. You can set roles for each user to permission the data the user can view or edit. This service may be used in conjunction with the Resource Owner Password Credentials OAuth flow or your own authentication service.

Parameter Type Description
id integer The id of the client within the user administration service
username string User’s unique username for the application. Should be mapped to the username in the Client entity.
password string User’s unique password for the application. All passwords should be passed as plain text and will be encrypted and stored using the Bcrypt algorithm.
authorities string The role for the user. Available values are ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, ROLE_ADVISOR, ROLE_CLIENT. Please view the Authorities resource for more information on each role. To view what endpoints each role permissions, please see this guide
is_account_non_expired boolean Sets the account to be expired if false.
is_account_non_locked boolean Sets the account to be locked if false.
is_credentials_non_expired boolean Sets the credentials to be expired if false.
is_enabled boolean Indicates that the client is enabled if true
tenant string The name of the tenant instance the user falls under, corresponding to the client_id provided for API Authentication

List all clients

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
  "https://api.hydrogenplatform.com/admin/v1/client"

Example Response

{
    "content": [
        {
            "id":29,
            "username": "[email protected]",
            "password": "$2a$10$R0FHWcxDLn4ts65cFMSq2uvt12bWX44PCUwXbhzRWlMYJbHBNHy3i",
            "is_account_non_expired": true,
            "is_account_non_locked": true,
            "is_credentials_non_expired": true,
            "is_enabled": false,
            "authorities": "ROLE_ADMIN",
            "tenant": "TenantName"
        },
        {
            "id": 28,
            "username": "[email protected]",
            "password": "$2a$10$D.239fir3z8x8RTybjmSguiQSdrpV5ktV8pY/g3M5WmNXVPVQwcWm",
            "is_account_non_expired": true,
            "is_account_non_locked": true,
            "is_credentials_non_expired": true,
            "is_enabled": true,
            "authorities": "ROLE_CLIENT",
            "tenant": "TenantName"
        },
        {
            "id": 27,
            "username": "[email protected]",
            "password": "$2a$10$7BYVHGi3zsmRwz83rFDqXedU/Xegckma/h23j1XlumtlkDayfEBGi",
            "is_account_non_expired": true,
            "is_account_non_locked": true,
            "is_credentials_non_expired": true,
            "is_enabled": true,
            "authorities": "ROLE_PORTFOLIO_MANAGER",
            "tenant": "TenantName"
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get information for all clients defined for your application. You can filter using any of the parameters except for password.

HTTP REQUEST

GET /admin/v1/client

Create a client

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
       "username": "[email protected]",
       "password": "client123Password",
       "authorities": "ROLE_ADMIN"
    }' "https://api.hydrogenplatform.com/admin/v1/client"

Example Response

{
    "id": 28,
    "username": "[email protected]",
    "password": "$2a$10$D.239fir3z8x8RTybjmSguiQSdrpV5ktV8pY/g3M5WmNXVPVQwcWm",
    "is_account_non_expired": true,
    "is_account_non_locked": true,
    "is_credentials_non_expired": true,
    "is_enabled": true,
    "authorities": "ROLE_CLIENT",
    "tenant": "TenantName"
}

HTTP REQUEST

POST /admin/v1/client

ARGUMENTS

Parameter Type Required Description
username string required User’s unique username for the application. Should be mapped to the username in the Client entity.
password string required User’s unique password for the application. All passwords should be passed as plain text and will be encrypted and stored using the Bcrypt algorithm.
authorities string required The role for the user. Available values are ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, ROLE_ADVISOR, ROLE_CLIENT. Please view the Authorities resource for more information on each role. To view what endpoints each role permissions, please see this guide
is_account_non_expired boolean optional Sets the account to be expired if false. Defaults to true.
is_account_non_locked boolean optional Sets the account to be locked if false. Defaults to true.
is_credentials_non_expired boolean optional Sets the credentials to be expired if false. Defaults to true.
is_enabled boolean optional Indicates that the client is enabled if true. Defaults to true.

Retrieve a client

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
  "https://api.hydrogenplatform.com/admin/v1/client/28"

Example Response

{
    "id": 28,
    "username": "[email protected]",
    "password": "$2a$10$D.239fir3z8x8RTybjmSguiQSdrpV5ktV8pY/g3M5WmNXVPVQwcWm",
    "is_account_non_expired": true,
    "is_account_non_locked": true,
    "is_credentials_non_expired": true,
    "is_enabled": true,
    "authorities": "ROLE_CLIENT",
    "tenant": "TenantName"
}

Retrieve the information for a specific client. The unique id must be provided.

HTTP REQUEST

GET /admin/v1/client/{id}

Update a client

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
        "is_account_non_locked": false
    }' "https://api.hydrogenplatform.com/admin/v1/client/28"

Example Response

{
    "id": 28,
    "username": "[email protected]",
    "password": "$2a$10$D.239fir3z8x8RTybjmSguiQSdrpV5ktV8pY/g3M5WmNXVPVQwcWm",
    "is_account_non_expired": true,
    "is_account_non_locked": false,
    "is_credentials_non_expired": true,
    "is_enabled": true,
    "authorities": "ROLE_CLIENT",
    "tenant": "TenantName"
}

Update the information for a client. All of the parameters can be updated except for username and tenant.

HTTP REQUEST

PUT /admin/v1/client/{id}

Fields

IDs

All Object IDs are represented in universally unique identifier (UUID) format. A UUID is a string of 32 alphanumeric characters in the format 8-4-4-4-12. An example would be efa289b2-3565-42e6-850b-8dad25727e99. Object IDs do not need to be specified. When using the POST method to create a new object, the ID will be returned as part of the response in the field id:

STRINGS

All strings are limited to 255 characters unless otherwise noted.

DATES

All dates are represented in ISO 8601 format YYYY-MM-DD. An example would be 2018-01-10.

TIMESTAMPS

All object responses will include a create_date and update_date in timestamp format. All timestamps are represented in ISO 8601 format YYYY-MM-DDThh:mm:ssTZD. The “T” appears before the time element and the TZD before the time zone. An example would be 2018-01-10T16:00:30+01:00.

Errors

ERROR CODES

Code Description
400 Bad Request
401 Unauthorized. Occurs when you are using an invalid or expired access token.
403 Forbidden. The request was valid but you are not authorized to access the resource.
404 Not Found. Occurs when you are requesting a resource which doesn’t exist such as an incorrect URL, incorrect ID, or empty result.
429 Too Many Requests. Exceeded the rate limit set. Currently, there is no rate limit on the APIs.
500 Internal Server Error.
503 Service Unavailable. If the API is down for maintenance you will see this error.


STATUS CODES

Code Description
200 Ok. The request was successful.
204 No Content. The request was successful but there is no additional content to send in the response body. This will occur on a successful DELETE.

Versioning

The Nucleus API is currently in major version 1.0. All features which are not backwards compatible will be pushed as a major version release. Features that we consider to be backwards compatible include the following:

Changelog

Date Change Description
2019-08-22 addition Added ability to link a client_id to a Bank Link and aggregation_accounts to a Budget.
2019-07-11 addition Created new entities including Aggregation Account Transaction, Aggregation Account Holding, Budget, and Financial Offer. Added total_earnings stat to Performance and metadata to remaining services.
2019-03-06 addition Implemented Access Control List (ACL) framework to permission user-specific access to endpoints and data records. Framework includes Authorities, Permission Types, Resource Owner Password Credentials, and User Administration service.
2018-11-30 addition Added new optional fields to the Client, Bank Link, Withdrawal, and Questionnaire entities. Created new entities including Aggregation Account, Aggregation Account Balance, Score, Client-Hydro, and Goal Track.
2018-09-07 addition Added new optional fields to the Goal entity. Added two new orchestration endpoints to subscribe an Account to an allocation and to change the composition of a Model.

Pagination

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account?
    page=0&size=10&order_by=id&ascending=true"

Example Response

{
    "content": [
    ],
    "first": true,
    "last": false,
    "number_of_elements": 10,
    "total_elements": 29,
    "total_pages": 3,
    "size": 10,
    "number": 0,
    "sort": [
        {
            "direction": "ASC",
            "property": "id",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": true,
            "descending": false
        }
]

For API resources that return a large volume of results you may use pagination. When using these “List all” API methods, rather than returning a large list of results, the results will be paginated by default. Please note that pagination is not available on some API resources, specified in the description of the resource.

ARGUMENTS

Parameter Type Description
page
optional
integer Page number for the page that should be returned as the starting page. For example, if this is specified as 0, then the first page of the results will be the shown, if it is set as 3 then the third page of the results will be shown, and so on. The default is 0
size
optional
integer The number or records to be included per page. The default is 25. There is no max value.
order_by
optional
string The field in the response body to order the list by. Default is update_date.
ascending
optional
boolean If true, order the results in ascending order. For an alphabetical result this would be A-Z. If false, order the results in descending order. For an alphabetical result this would be Z-A. Default is false which would order by descending.

Filters

Example Requests

Filter the Account object to pull back all accounts that are a specified account type:

/account?filter=account_type==e4f07fc6-1020-43b8-a1ce-18031671e8e0

Filter the Account object to pull back all accounts that are assigned to a specified goal, which is an object embedded in Account:

/account?filter=goals.goal_id==f87fd7e1-b73d-40b1-9747-74e2b421dd94

Filter all accounts that are assigned to a specified goal, AND are a specified account type:

/account?filter=goals.goal_id==47608aa1-a0f5-4d1b-957a-9dc58da9193f
;account_type==553b8534-c406-4ded-9045-5ee6007c5d91

Every field within an object using the GET method can be filtered except for fields stored under metadata. Filtering is especially useful for calls that return many different fields.

A filter query may consist of one or more logical comparisons:

AND: ; or and
OR: , or or

To group multiple OR statements together, you must add () at the beginning and end of the list of statements

/account?filter=(account_type==553b8534-c406-4ded-9045-5ee6007c5d91,account_type==87e4991b-e2a2-4c14-a3e6-407cbcb01cdf,account_type==b00b6eea-8ab1-4d5a-9c84-4c958d795680);goals.goal_id==47608aa1-a0f5-4d1b-957a-9dc58da9193f

Comparison operators may consist of the following:

Equal to: ==
Not equal to: !=
Less than: =lt= or <
Less than or equal to: =le= or <=
Greater than: =gt= or >
Greater than or equal to: =ge= or >=
In: =in=
Not in: =out=

The basic construct for a filtering query is as follows:

/<endpoint>?filter=<query>

To filter using a simple one word field within an object, the query would be as follows:

/<endpoint>?filter=<fieldname>==<fieldvalue>

To filter using a field with multiple words, replace the space between each word with an underscore. The query would be as follows:

/<endpoint>?filter=<fieldname>==<fieldvalue_fieldvalue>

To filter using a field within an embedded object, the query would be as follows:

/<endpoint>?filter=<objectname>.<fieldname>==<fieldvalue>

To filter using the =in= or =out= options, include a series of comma-separated values wrapped in parentheses, with no spaces between values. The query would be as follows:

/<endpoint>?filter=<fieldname>=in=(<fieldvalue>,<fieldvalue>,<fieldvalue>)

Metadata

Many objects support optional metadata fields, as denoted in the documentation. Metadata is intended to allow developers to extend our API and store custom information that is relevant to their business. Some examples may include:

Metadata may consist of any key-value pair you define such as “Age”:”35” or “City”:”New York”

All metadata that is entered will be returned in the JSON and may consist of up to 255 alphanumeric, string, integer, and boolean characters for each key and each value.

When updating the metadata using any of the PUT endpoints, you should provide both the details you wish to maintain as well as the details you wish to update.

General & Onboarding

Account

Account Management

Accounts are created below clients to represent an account on your firm’s platform, such as an investment account. One or more portfolios can be created below an account and map to models. Accounts will subscribe to an allocation. This will determine the composition of the portfolios and models below the account. Generally, an account will subscribe to an allocation for each goal that is associated with the account. An account may also be associated with one or more goals.

Field Type Description
id UUID The id for the account
name string Name of the account
account_type_id UUID The id of the account type for the account. Account types are defined by your firm
managed boolean Indicates if the account is managed or self directed. Defaults to true, or that it’s managed
clients array List of clients associated with the account and their association type as well as signature data
      client_id UUID The id of a client associated with the account
      client_account_association_type string The role of the client as it relates to the account defined by your firm. Roles may be joint, owner, trustee, viewer, or admin. Automatically grants the FULL_AUTHORITY permission type to clients mapped to the account with the client_account_association_type of owner, joint, trustee or admin and the INQUIRY_ACCESS permission type to clients mapped to the account with the client_account_association_type of viewer
      signature_data longtext Stored signature for the client on the account such as a Base30 or Base64 string
goals array List of goals mapped to the account with information such as goal amount and horizon
      goal_id UUID The id of a goal mapped to the account
      goal_amount double Monetary amount provided by the client as the target amount to be reached within the goal horizon. May be used in conjunction with the Proton API. Option to also store under the goal entity
      accumulation_horizon double Time horizon of the goal during the accumulation phase, in years. May be used in conjunction with the Proton API. Option to also store under the goal entity
      decumulation_horizon double Time horizon of the goal during the decumulation phase, in years. If the goal is an accumulation goal, then this can be 0 or omitted entirely. May be used in conjunction with the Proton API. Option to also store under the goal entity
currency_code string Alphabetic currency code for the base currency of the account, limited to 3 characters. See currency codes
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all accounts

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
try:
    # Get information for all accounts for all clients defined for your firm
    api_response = api_instance.get_accounts()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_accounts: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #Get information for all accounts for all clients defined for your firm
  result = api_instance.get_accounts()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_accounts: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountResponse result = apiInstance.getAccounts();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccounts");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccounts(opts, callback);

Example Response

{
    "content": [
        {
            "id": "099961da-7f41-4309-950f-2b51689a0033",
            "create_date": "2017-01-03T00:00:00.000+0000",
            "update_date": "2017-01-05T00:00:00.000+0000",
            "secondary_id": "7289243787238",
            "managed": true,
            "name": "Joint IRA 23",
            "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "clients": [
                {
                    "client_id": "099961da-7f41-4309-950f-2b51689a0033",
                    "client_account_association_type": "joint"
                }
            ],
            "goals": [
                {
                    "goal_id": "099961da-7f41-4309-950f-2b51689a0033",
                    "goal_amount": 200000,
                    "accumulation_horizon": 35,
                    "decumulation_horizon": 25
                }
            ],
            "currency_code": "USD",
            "metadata": {}
        },
        {
            "id": "107516c3-9035-4811-af7c-501be5a1fe26",
            "create_date": "2017-02-14T00:00:00.000+0000",
            "update_date": "2017-02-15T09:00:00.000+0000",
            "managed": true,
            "name": "Investment Account 87 - Admin Owned",
            "account_type_id": "39770e8d-890d-485b-822e-5a1578f26d47",
            "clients": [
                {
                    "client_id": "107516c3-9035-4811-af7c-501be5a1fe26",
                    "client_account_association_type": "admin"
                }
            ],
            "goals": [
                {
                    "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
                    "goal_amount": 40000,
                    "accumulation_horizon": 10,
                }
            ],
            "metadata": {}
        },
        {
            "id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "create_date": "2017-03-01T00:00:00.000+0000",
            "update_date": "2018-01-05T00:00:00.000+0000",
            "managed": true,
            "name": "Investment Account 60",
            "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
            "clients": [
                {
                    "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
                    "client_account_association_type": "owner"
                }
            ],
            "goals": [
                {
                    "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
                    "goal_amount": 100000,
                    "accumulation_horizon": 15
                }
            ],
            "metadata": {}
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get information for all accounts for all clients defined for your firm. You can filter using a unique client_id to view the accounts for a client. To identify the appropriate client_id, use the GET /client endpoint to see all clients defined for your firm. Note that the information for the clients associated with the account, the goals information, and the metadata information are stored as nested objects within the account object.

HTTP REQUEST

GET /account

Create an account

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
      "secondary_id": "7289243787238",
      "name": "Investment Account 60",
      "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
      "clients": [
        {
            "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "client_account_association_type": "owner"
        }
      ],  
      "goals": [
        {
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "goal_amount": 100000,
            "accumulation_horizon": 15
        }
      ]
    }' "https://api.hydrogenplatform.com/nucleus/v1/account"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

client = atom_api.AccountCreateClient(client_id="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    client_account_association_type="owner")
goal = atom_api.AccountCreateGoal(goal_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
    goal_amount=100000,
    accumulation_horizon=15)

payload = atom_api.AccountCreatePayload(name="Investment Account 60",
    account_type_id="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client],
    goals=[goal],
    secondary_id="7289243787238")

try:
    # Create an account under a client
    api_response = api_instance.post_account(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_account: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AccountCreatePayload.new
payload.name = "Investment Account 60"
payload.account_type_id = "eb3d7f60-a133-4ca9-815f-3677bcdc23a3"

client = AtomApi::AccountCreateClient.new
client.client_id = "199a8c08-cdd5-4c8c-8abf-535447cea11b"
client.client_account_association_type = "owner"
payload.clients = [client]

goal = AtomApi::AccountCreateGoal.new
goal.goal_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
goal.goal_amount = 100000
goal.accumulation_horizon = 15
payload.goals = [goal]
payload.secondary_id = "7289243787238"

begin
  #Create an account under a client
  result = api_instance.post_account(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_account: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AccountCreateClient client1 = new AccountCreateClient(clientId="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    clientAccountAssociationType="owner");
AccountCreateGoal goal1 = new AccountCreateGoal(goalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    goalAmount=100000,
    accumulationHorizon=15);
AccountCreatePayload payload = new AccountCreatePayload(name="Investment Account 60",
    accountTypeId="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client1],
    goals=[goal1],
    secondaryId="7289243787238");
try {
    CreateAccountResponse result = apiInstance.postAccount(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAccount");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();
var client1 = new atom_api.AccountCreateClient(clientId="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    clientAccountAssociationType="owner");
var goal1 = new atom_api.AccountCreateGoal(goalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    goalAmount=100000,
    accumulationHorizon=15);
var payload = new atom_api.AccountCreatePayload(name="Investment Account 60",
    accountTypeId="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client1],
    goals=[goal1],
    secondaryId="7289243787238");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAccount(payload, callback);

Example Response

{
    "id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
    "create_date": "2017-03-01T00:00:00.000+0000",
    "secondary_id": "7289243787238",
    "managed": true,
    "name": "Investment Account 60",
    "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    "clients": [
        {
            "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "client_account_association_type": "owner"
        }
    ],
    "goals": [
        {
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "goal_amount": 100000,
            "accumulation_horizon": 15
        }
    ],
    "metadata": {}
}

Create an account under a client. In order to create an account, the client must have already registered and the client_id must be provided. To identify the appropriate client_id, use the GET /client endpoint to see all clients for your firm. The client can be an internal user. The endpoint returns an account_id that can then be mapped to other entities such as goal, allocation, and portfolio or used to create funding requests.

HTTP REQUEST

POST /account

ARGUMENTS

Parameter Type Required Description
name string required Name of the account
account_type_id UUID required The id of the account type for the account. Account types are defined by your firm
managed boolean optional Indicates if the account is managed or self directed. Defaults to true, or that it’s managed
clients array optional List of clients associated with the account and their association type as well as signature data
      client_id UUID required The id of a client associated with the account
      client_account_association_type string required The role of the client as it relates to the account defined by your firm. Roles may be joint, owner, trustee, viewer, or admin. Automatically grants the FULL_AUTHORITY permission type to clients mapped to the account with the client_account_association_type of owner, joint, trustee or admin and the INQUIRY_ACCESS permission type to clients mapped to the account with the client_account_association_type of viewer
      signature_data longtext optional Stored signature for the client on the account such as a Base30 or Base64 string
goals array optional List of goals mapped to the account with information such as goal amount and horizon
      goal_id UUID required The id of a goal mapped to the account
      goal_amount double optional Monetary amount provided by the client as the target amount to be reached within the goal horizon. May be used in conjunction with the Proton API. Option to also store under the goal entity
      accumulation_horizon double optional Time horizon of the goal during the accumulation phase, in years. May be used in conjunction with the Proton API. Option to also store under the goal entity
      decumulation_horizon double optional Time horizon of the goal during the decumulation phase, in years. If the goal is an accumulation goal, then this can be 0 or omitted entirely. May be used in conjunction with the Proton API. Option to also store under the goal entity
currency_code string optional Alphabetic currency code for the base currency of the account, limited to 3 characters. See currency codes
metadata map optional Custom information associated with the account in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Subscribe an account

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d ' {
            "current_weight" : "50",
            "strategic_weight": "50",
            "date": "2018-06-28",
            "allocation_id": "cb831ad5-18d0-48b3-9d8e-8db318b51895",  
            "goal_id": "a65929b6-b0a9-46e5-858a-121f0b10f4fb"
         }' "https://api.hydrogenplatform.com/nucleus/v1/account/dbebf51f-d325-4cdd-b043-78958e29bdce/subscribe"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = 'dbebf51f-d325-4cdd-b043-78958e29bdce'
payload = atom_api.AccountSubscribePayload(current_weight=50,
   strategic_weight=50,
   _date="2018-06-28",
   allocation_id="cb831ad5-18d0-48b3-9d8e-8db318b51895",
   goal_id="a65929b6-b0a9-46e5-858a-121f0b10f4fb")

try:
    # Subscribe an account
    api_response = api_instance.subscribe_account(account_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->subscribe_account: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = 'dbebf51f-d325-4cdd-b043-78958e29bdce'

payload = AtomApi::AccountSubscribePayload.new
payload.current_weight = 50
payload.strategic_weight = 50
payload.date = "2018-06-28"
payload.allocation_id = "cb831ad5-18d0-48b3-9d8e-8db318b51895"
payload.goal_id = "a65929b6-b0a9-46e5-858a-121f0b10f4fb"

begin
  #Subscribe an account
  result = api_instance.subscribe_account(account_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->subscribe_account: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("dbebf51f-d325-4cdd-b043-78958e29bdce");
AccountSubscribePayload payload = new AccountSubscribePayload(currentWeight=50,
      strategicWeight=50,
      date="2018-06-28",
      allocationId="cb831ad5-18d0-48b3-9d8e-8db318b51895",
      goalId="a65929b6-b0a9-46e5-858a-121f0b10f4fb");
try {
    SubscribeAccountResponse result = apiInstance.subscribeAccount(accountId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#subscribeAccount");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "dbebf51f-d325-4cdd-b043-78958e29bdce";

var payload = new atom_api.AccountSubscribePayload(currentWeight=50,
   strategicWeight=50,
   date="2018-06-28",
   allocationId="cb831ad5-18d0-48b3-9d8e-8db318b51895",
   goalId="a65929b6-b0a9-46e5-858a-121f0b10f4fb");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.subscribeAccount(accountIdpayload, callback);

Example Response

[
    {
        "id": "ab70c3e0-beec-4165-b08e-eef78e3f3962",
        "create_date": "2018-06-28T18:17:23.579+0000",
        "update_date": "2018-06-28T18:17:23.579+0000",
        "description": "High Income Stock",
        "name": "High-Income Stock",
        "percentage": 25,
        "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
        "model_id": "62fd0a9f-4bac-4b1d-94d2-2c5ea2adca3d",
        "metadata": {}
    },
    {
        "id": "54c97821-910c-4199-9f8d-7ba94a56a80d",
        "create_date": "2018-06-28T18:17:23.579+0000",
        "update_date": "2018-06-28T18:17:23.579+0000",
        "description": "Tactical Industrial Stock",
        "name": "Industrial Stocks",
        "percentage": 25,
        "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
        "model_id": "778b8996-6579-46d9-86ce-a097f189ac7f",
        "metadata": {}
    },
    {
        "id": "d206b198-960a-4e8c-a9e3-83958b5ccb96",
        "create_date": "2018-06-28T18:17:23.579+0000",
        "update_date": "2018-06-28T18:17:23.579+0000",
        "description": "Dynamic ESG Nasdaq Stock",
        "name": "Concentrated Aggressive SRI Core",
        "percentage": 50,
        "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
        "model_id": "88d8f74a-0959-410c-8d01-09cf8f7fe55d",
        "metadata": {}
    }
]

After creating an account, you may create portfolios for the account to track a client’s investment, savings, or insurance products. The composition of each portfolio is determined by the models in each allocation that the portfolio is subscribed to. This endpoint combines the following three actions into one workflow:

1) Create a relationship between an account and an allocation
2) Retrieve the allocation’s model composition
3) Create portfolios for the account that subscribe to models in the allocation

The endpoint takes in an account_id in the URL and the same parameters as the POST /account_allocation endpoint and returns ids for the portfolios created. The details for the portfolios such as the name and description are taken from the corresponding model.

HTTP REQUEST

POST /account/{account_id}/subscribe

ARGUMENTS

Parameter Type Required Description
current_weight double required Current percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The current weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
strategic_weight double required Strategic percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The strategic weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
date date required Date of the account-allocation mapping used for historical tracking
allocation_id UUID required The id of the allocation that is part of the account-allocation mapping
goal_id UUID optional The id of the goal that is associated with this account-allocation mapping

RESPONSE

Field Type Description
id UUID The id of the portfolio
name string Name of the portfolio such as “Stock”
account_id UUID The id of the account to which the portfolio belongs
model_id UUID The id of the model to which the portfolio subscribes
percentage double Weight of the portfolio as a percentage of an account based on the weight of the portfolio’s model within the account’s allocation; ex. 20 representing 20%. If the account only has one portfolio input 100
description string Description for the portfolio such as “Stock Portfolio”
metadata map Custom information associated with the portfolio in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Retrieve an account

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account/199a8c08-cdd5-4c8c-8abf-535447cea11b"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'

try:
    # Retrieve an account
    api_response = api_instance.get_account(account_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'

begin
  #Retrieve an account
  result = api_instance.get_account(account_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("199a8c08-cdd5-4c8c-8abf-535447cea11b");
try {
    SpecificAccountResponse result = apiInstance.getAccount(accountId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccount");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "199a8c08-cdd5-4c8c-8abf-535447cea11b";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccount(accountId, callback);

Example Response

{
    "id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
    "create_date": "2017-03-01T00:00:00.000+0000",
    "update_date": "2018-01-05T00:00:00.000+0000",
    "managed": true,
    "name": "Investment Account 60",
    "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    "clients": [
        {
            "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "client_account_association_type": "owner"
        }
    ],
    "goals": [
        {
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "goal_amount": 100000,
            "accumulation_horizon": 15
        }
    ],
    "metadata": {}
}

Retrieve the information for a specific account associated with a client. The unique account_id must be provided. The endpoint returns the account_id and details for the account specified. Note that the information for the clients associated with the account, the goals information, and the metadata information are stored as nested objects within the account object.

HTTP REQUEST

GET /account/{account_id}

Update an account

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
      "name": "Investment Account 60",
      "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
      "clients": [
        {
            "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "client_account_association_type": "owner"
        }
      ],
      "goals": [
        {
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "goal_amount": 100000,
            "accumulation_horizon": 15
        }
      ]
    }' "https://api.hydrogenplatform.com/nucleus/v1/account/199a8c08-cdd5-4c8c-8abf-535447cea11b"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'
client = atom_api.AccountCreateClient(client_id="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    client_account_association_type="owner")
goal = atom_api.AccountCreateGoal(goal_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
    goal_amount=100000,
    accumulation_horizon=15)

payload = atom_api.AccountCreatePayload(name="Investment Account 60",
    account_type_id="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client],
    goals=[goal])

try:
    # Update an account
    api_response = api_instance.update_account(account_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'

payload = AtomApi::AccountCreatePayload.new
payload.name = "Investment Account 60"
payload.account_type_id = "eb3d7f60-a133-4ca9-815f-3677bcdc23a3"

client = AtomApi::AccountCreateClient.new
client.client_id = "199a8c08-cdd5-4c8c-8abf-535447cea11b"
client.client_account_association_type = "owner"
payload.clients = [client]

goal = AtomApi::AccountCreateGoal.new
goal.goal_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
goal.goal_amount = 100000
goal.accumulation_horizon = 15
payload.goals = [goal]

begin
  #Update an account
  result = api_instance.update_account(account_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("199a8c08-cdd5-4c8c-8abf-535447cea11b");
AccountCreateClient client1 = new AccountCreateClient(clientId="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    clientAccountAssociationType="owner");
AccountCreateGoal goal1 = new AccountCreateGoal(goalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    goalAmount=100000,
    accumulationHorizon=15);
AccountCreatePayload payload = new AccountCreatePayload(name="Investment Account 60",
    accountTypeId="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client1],
    goals=[goal1],
    secondaryId="7289243787238");
try {
    SpecificAccountResponse result = apiInstance.updateAccount(accountId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccount");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "199a8c08-cdd5-4c8c-8abf-535447cea11b";

var client1 = new AccountCreateClient(clientId="199a8c08-cdd5-4c8c-8abf-535447cea11b",
    clientAccountAssociationType="owner");
var goal1 = new AccountCreateGoal(goalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
  goalAmount=100000,
  accumulationHorizon=15);

var payload = new atom_api.AccountCreatePayload(name="Investment Account 60",
    accountTypeId="eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    clients=[client1],
    goals=[goal1],
    secondaryId="7289243787238");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccount(accountIdpayload, callback);

Example Response

{
    "id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
    "create_date": "2017-03-01T00:00:00.000+0000",
    "update_date": "2018-01-05T00:00:00.000+0000",
    "managed": true,
    "name": "Investment Account 60",
    "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
    "clients": [
        {
            "client_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
            "client_account_association_type": "owner"
        }
    ],
    "goals": [
        {
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "goal_amount": 100000,
            "accumulation_horizon": 15
        }
    ],
    "metadata": {}
}

Update the information for an account. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the account_id and the details for the account. If you wish to mark the account as closed without permanently deleting it, use this endpoint to update the managed field to false.

HTTP REQUEST

PUT /account/{account_id}

Delete an account

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account/199a8c08-cdd5-4c8c-8abf-535447cea11b"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'

try:
    # Delete an account
    api_instance.delete_account(account_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '199a8c08-cdd5-4c8c-8abf-535447cea11b'

begin
  #Delete an account
  api_instance.delete_account(account_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("199a8c08-cdd5-4c8c-8abf-535447cea11b");
try {
    apiInstance.deleteAccount(accountId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccount");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "199a8c08-cdd5-4c8c-8abf-535447cea11b";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccount(accountId, callback);

Response (204 No Content)

Permanently delete an account under a client. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm. This deletes the account_id and all account record information. If you wish to mark the account as closed without permanently deleting it, use the PUT /account endpoint to update the managed field to false.

HTTP REQUEST

DELETE /account/{account_id}

Account Allocation

Accounts can subscribe to one or more allocations, which can be tracked over time. An allocation can also optionally map to a goal. The account-allocation mapping indicates what percentage of an account’s funds should be directed towards an allocation.

Field Type Description
id UUID The id for the account-allocation mapping
allocation_id UUID The id of the allocation that is part of the account-allocation mapping
current_weight double Current percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The current weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
strategic_weight double Strategic percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The strategic weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
account_id UUID The id of the account that is part of the account-allocation mapping
date date Date of the account-allocation mapping used for historical tracking
goal_id UUID The id of the goal that is associated with this account-allocation mapping

List all account allocations

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_allocation"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all account allocations
    api_response = api_instance.get_account_allocations()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_allocations: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all account allocations
  result = api_instance.get_account_allocations()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_allocations: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountAllocationResponse result = apiInstance.getAccountAllocations();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountAllocations");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountAllocations(opts, callback);

Example Response

{
    "content": [
        {
            "id": "000183ac-2288-4564-a76b-119f4694be98",
            "current_weight": 100,
            "date": "2016-01-01",
            "strategic_weight": 100,
            "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
            "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
        },
        {
            "id": "0007b32a-5765-48d6-afd0-2d990818bced",
            "current_weight": 50,
            "date": "2017-01-01",
            "strategic_weight": 50,
            "allocation_id": "88eed960-dad5-4954-a4ba-bd120b0e8dfb",
            "goal_id": "2a7a6cb7-ef71-4fe8-9169-2678f3799657",
            "account_id": "1dfb2510-486b-47d7-89b3-c48a24c0e584"
        },
        {
            "id": "000bca42-8461-4248-a5ff-a5d1f5716e27",
            "current_weight": 50,
            "date": "2017-01-01",
            "strategic_weight": 50,
            "allocation_id": "39770e8d-890d-485b-822e-5a1578f26d47",
            "goal_id": "2a7a6cb7-ef71-4fe8-9169-2678f3799657",
            "account_id": "1dfb2510-486b-47d7-89b3-c48a24c0e584"
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get information for all account-allocation mappings for all accounts defined for your firm. You can filter using a unique account_id to view the allocations mapping to an account. To identify the appropriate account_id, use the GET /account endpoint to see all accounts defined for your firm.

HTTP REQUEST

GET /account_allocation

Create an account allocation

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
      "current_weight": 100,
      "date": "2016-01-01",
      "strategic_weight": 100,
      "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
      "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
      "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
   }' "https://api.hydrogenplatform.com/nucleus/v1/000183ac-2288-4564-a76b-119f4694be98"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AccountAllocationPayload(allocation_id="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    current_weight=100,
    strategic_weight=100,
    account_id="dbebf51f-d325-4cdd-b043-78958e29bdce",
    _date="2016-01-01",
    goal_id="647c54c3-b649-477e-8cc7-eee56a120dd3")

try:
    # Create an account allocation
    api_response = api_instance.post_account_allocation(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_account_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AccountAllocationPayload.new
payload.allocation_id = "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6"
payload.current_weight = 100
payload.strategic_weight = 100
payload.account_id = "dbebf51f-d325-4cdd-b043-78958e29bdce"
payload.date = "2016-01-01"
payload.goal_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"

begin
  #Create an account allocation
  result = api_instance.post_account_allocation(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_account_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AccountAllocationPayload payload = new AccountAllocationPayload(allocationId="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    currentWeight=100,
    strategicWeight=100,
    accountId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    date="2016-01-01",
    goalId="647c54c3-b649-477e-8cc7-eee56a120dd3");
try {
    SpecificAccountAllocationResponse result = apiInstance.postAccountAllocation(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAccountAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AccountAllocationPayload(allocationId="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    currentWeight=100,
    strategicWeight=100,
    accountId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    date="2016-01-01",
    goalId="647c54c3-b649-477e-8cc7-eee56a120dd3");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAccountAllocation(payload, callback);

Example Response

{
    "id": "000183ac-2288-4564-a76b-119f4694be98",
    "current_weight": 100,
    "date": "2016-01-01",
    "strategic_weight": 100,
    "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
}

Create an account-allocation mapping for an account. This indicates how much of the account’s funds should be directed towards the allocation specified. The account_id and the allocation_id must be provided. To obtain the appropriate account_id use the GET /account endpoint to view all accounts for your firm. To obtain the appropriate allocation_id use the GET /allocation endpoint to view all allocations defined by your firm. The endpoint returns an account_allocation_id used to manage the account-allocation mapping.

HTTP REQUEST

POST /account_allocation

ARGUMENTS

Parameter Type Required Description
allocation_id UUID required The id of the allocation that is part of the account-allocation mapping
current_weight double required Current percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The current weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
strategic_weight double required Strategic percentage of the account’s total value that should be directed towards the allocation; ex. 20 representing 20%. The strategic weights for all allocations below an account must add up to 100. If the allocation is the only one, enter 100
account_id UUID required The id of the account that is part of the account-allocation mapping
date date required Date of the account-allocation mapping used for historical tracking
goal_id UUID optional The id of the goal that is associated with this account-allocation mapping

Retrieve an account allocation

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_allocation/000183ac-2288-4564-a76b-119f4694be98"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_allocation_id = '000183ac-2288-4564-a76b-119f4694be98'

try:
    # Retrieve an account allocation
    api_response = api_instance.get_account_allocation(account_allocation_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_allocation_id = '000183ac-2288-4564-a76b-119f4694be98'

begin
  #Retrieve an account allocation
  result = api_instance.get_account_allocation(account_allocation_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountAllocationId = new UUID("000183ac-2288-4564-a76b-119f4694be98");
try {
    SpecificAccountAllocationResponse result = apiInstance.getAccountAllocation(accountAllocationId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountAllocationId = "000183ac-2288-4564-a76b-119f4694be98";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountAllocation(accountAllocationId, callback);

Example Response

{
    "id": "000183ac-2288-4564-a76b-119f4694be98",
    "current_weight": 100,
    "date": "2016-01-01",
    "strategic_weight": 100,
    "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
}

Retrieve the information for a specific account-allocation mapping for an account. The unique account_allocation_id must be provided. The endpoint returns the account_allocation_id and details for the account-allocation mapping specified.

HTTP REQUEST

GET /account_allocation/{account_allocation_id}

Update an account allocation

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
        "current_weight": 100,
        "date": "2016-01-01",
        "strategic_weight": 100,
        "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
        "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
        "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_allocation/000183ac-2288-4564-a76b-119f4694be9"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_allocation_id = '000183ac-2288-4564-a76b-119f4694be9'
payload = atom_api.AccountAllocationPayload(allocation_id="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    current_weight=100,
    strategic_weight=100,
    account_id="dbebf51f-d325-4cdd-b043-78958e29bdce",
    _date="2016-01-01",
    goal_id="dbebf51f-d325-4cdd-b043-78958e29bdce")

try:
    # Update an account allocation
    api_response = api_instance.update_account_allocation(account_allocation_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_allocation_id = '000183ac-2288-4564-a76b-119f4694be9'

payload = AtomApi::AccountAllocationPayload.new
payload.allocation_id = "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6"
payload.current_weight = 100
payload.strategic_weight = 100
payload.account_id = "dbebf51f-d325-4cdd-b043-78958e29bdce"
payload.date = "2016-01-01"
payload.goal_id = "dbebf51f-d325-4cdd-b043-78958e29bdce"

begin
  #Update an account allocation
  result = api_instance.update_account_allocation(account_allocation_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountAllocationId = new UUID("000183ac-2288-4564-a76b-119f4694be9");
AccountAllocationPayload payload = new AccountAllocationPayload(allocationId="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    currentWeight=100,
    strategicWeight=100,
    accountId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    date="2016-01-01",
    goalId="dbebf51f-d325-4cdd-b043-78958e29bdce");
try {
    SpecificAccountAllocationResponse result = apiInstance.updateAccountAllocation(accountAllocationId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccountAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountAllocationId = "000183ac-2288-4564-a76b-119f4694be9";

var payload = new atom_api.AccountAllocationPayload(allocationId="7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    currentWeight=100,
    strategicWeight=100,
    accountId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    date="2016-01-01",
    goalId="dbebf51f-d325-4cdd-b043-78958e29bdce");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccountAllocation(accountAllocationIdpayload, callback);

Example Response

{
    "id": "000183ac-2288-4564-a76b-119f4694be98",
    "current_weight": 100,
    "date": "2016-01-01",
    "strategic_weight": 100,
    "allocation_id": "7d0ae4cc-94f6-4fde-88e5-507888f9f6c6",
    "goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "account_id": "dbebf51f-d325-4cdd-b043-78958e29bdce"
}

Update the information for an account-allocation mapping. The unique account_allocation_id must be provided. To obtain the appropriate account_allocation_id, use the GET /account_allocation endpoint to view all account-allocation mappings and their current information. The details to be updated must also be provided. The endpoint returns the account_allocation_id and the details for the account-allocation mapping.

HTTP REQUEST

PUT /account_allocation/{account_allocation_id}

Delete an account allocation

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_allocation/000183ac-2288-4564-a76b-119f4694be9"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_allocation_id = '000183ac-2288-4564-a76b-119f4694be9'

try:
    # Delete an account allocation
    api_instance.delete_account_allocation(account_allocation_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_allocation_id = '000183ac-2288-4564-a76b-119f4694be9'

begin
  #Delete an account allocation
  api_instance.delete_account_allocation(account_allocation_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountAllocationId = new UUID("000183ac-2288-4564-a76b-119f4694be9");
try {
    apiInstance.deleteAccountAllocation(accountAllocationId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccountAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountAllocationId = "000183ac-2288-4564-a76b-119f4694be9";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccountAllocation(accountAllocationId, callback);

Response (204 No Content)

Permanently delete an account-allocation mapping for an account. The unique account_allocation_id must be provided. To obtain the appropriate account_allocation_id, use the GET /account_allocation endpoint to view all account-allocation mappings. This deletes the account_allocation_id and the association between an account and an allocation.

HTTP REQUEST

DELETE /account_allocation/{account_allocation_id}

Account Activity

List all account asset sizes

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account/50b4d384-986d-4892-a30a-bc4c146d25a9/asset_size"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

try:
    # List all account asset sizes
    api_response = api_instance.get_account_asset_sizes(account_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_asset_sizes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

begin
  #List all account asset sizes
  result = api_instance.get_account_asset_sizes(account_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_asset_sizes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("50b4d384-986d-4892-a30a-bc4c146d25a9");

try {
    GetAccountAssetSizeResponse result = apiInstance.getAccountAssetSizes(accountId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountAssetSizes");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "50b4d384-986d-4892-a30a-bc4c146d25a9";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountAssetSizes(accountId, opts, callback);

Example Response

[
    {
        "date": "2018-02-03",
        "value": 20000,
        "additions": 0
    },
    {
        "date": "2018-02-10",
        "value": 20543,
        "additions": 500
    }
]

Get a list of asset sizes by date for an account. Asset size records are created at the portfolio level and aggregated to yield the account asset size(s). The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view the accounts defined for your firm. The endpoint returns a list of asset sizes by date for the account. Additional parameters available to narrow down what is returned include date range, only obtaining the latest record, and sorting by different units of time (eg. annually, quarterly, monthly, daily).

HTTP REQUEST

GET /account/{account_id}/asset_size

ARGUMENTS

Parameter Type Required Description
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set
sort_type string optional Sort the asset sizes by D Daily, M Monthly, Q Quarterly, Y Yearly. Defaults to D Daily if not set. Must be capital letters
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
date date Date for this asset size record
value double Monetary value of the account on the particular date
additions double Amount added to the account value since the last asset size date, usually via deposit

List all account holdings

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account/50b4d384-986d-4892-a30a-bc4c146d25a9/holding"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

try:
    # List all account holdings
    api_response = api_instance.get_account_holdings(account_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_holdings: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

begin
  #List all account holdings
  result = api_instance.get_account_holdings(account_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_holdings: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("50b4d384-986d-4892-a30a-bc4c146d25a9");

try {
    GetAccountHoldingResponse result = apiInstance.getAccountHoldings(accountId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountHoldings");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "50b4d384-986d-4892-a30a-bc4c146d25a9";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountHoldings(accountId, opts, callback);

Example Response

[
    {
        "date": "2018-02-03",
        "security_id": "d6496a5a-a17e-4682-8c8e-7933ce6ca3c6",
        "weight": 10,
        "amount": 2000,
        "shares": 20
    },
    {
        "date": "2018-02-03",
        "security_id": "24c3f327-20ac-4302-8330-6cf19de9a353",
        "weight": 2,
        "amount": 400,
        "shares": 40
    },
    {
        "date": "2018-02-03",
        "security_id": "cc5a6c52-32a5-4cd8-98db-4541c9b29add",
        "weight": 30,
        "amount": 6000,
        "shares": 6
    },
    {
        "date": "2018-02-03",
        "security_id": "3c416c11-1e43-4031-bc0a-e9dc3677f15a",
        "weight": 30,
        "amount": 6000,
        "shares": 60
    },
    {
        "date": "2018-02-03",
        "security_id": "59add370-01cf-42a0-bee8-ad75065df603",
        "weight": 28,
        "amount": 5600,
        "shares": 50
    }
]

Get information for all the securities that are currently being held by an account. Holding records are created at a portfolio level and aggregated to show the holdings of the account. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view the accounts defined for your firm. The endpoint returns a list of security_ids and details for each security holding. Additional parameters available to narrow down what is returned include date range and only obtaining the latest record.

HTTP REQUEST

GET /account/{account_id}/holding

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set

RESPONSE

Field Type Description
date date Date for the security holding
security_id UUID The id for the security included in the holding record
weight double The weight of the security as a percentage of the account’s total monetary value; ex. 20 representing 20%
amount double Monetary value of the shares in the holding record
shares double Number of shares in the holding record

List all account transactions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account/50b4d384-986d-4892-a30a-bc4c146d25a9/transaction"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

try:
    # List all account transactions
    api_response = api_instance.get_account_transactions(account_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_transactions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = '50b4d384-986d-4892-a30a-bc4c146d25a9'

begin
  #List all account transactions
  result = api_instance.get_account_transactions(account_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_transactions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("50b4d384-986d-4892-a30a-bc4c146d25a9");
try {
    AccountTransactionResponse result = apiInstance.getAccountTransactions(accountId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountTransactions");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "50b4d384-986d-4892-a30a-bc4c146d25a9";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountTransactions(accountId, opts, callback);

Example Response

{
  "content": [
    {
        "id": "50b4d384-986d-4892-a30a-bc4c146d25a9",
        "date": "2018-01-31",
        "is_read": true,
        "portfolio_id": "c193de6e-564d-4b2d-893d-0307e92279b7",
        "model_id": "19ef73a9-8dd9-4df0-970e-c3f57c6f8d38",
        "price": 432.2,
        "quantity": 0.5,
        "security_id": "088c1dc6-6750-411d-8679-dfeeaa7241e3",
        "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386",
        "create_date": "2018-01-25T09:00:00.000+0000",
        "update_date": "2018-02-15T09:00:00.000+0000"
    },
    {
        "id": "97c771ac-64b7-461e-a5b3-7d93169dc58b",
        "date": "2018-01-31",
        "is_read": true,
        "portfolio_id": "c193de6e-564d-4b2d-893d-0307e92279b7",
        "model_id": "19ef73a9-8dd9-4df0-970e-c3f57c6f8d38",
        "price": 132.2,
        "quantity": 4,
        "security_id": "59add370-01cf-42a0-bee8-ad75065df603",
        "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386",
        "create_date": "2018-01-25T09:00:00.000+0000",
        "update_date": "2018-02-15T09:00:00.000+0000"
    }
  ],
  "total_pages": 1,
  "total_elements": 2,
  "last": true,
  "sort": [
    {
        "direction": "DESC",
        "property": "id",
        "ignore_case": false,
        "null_handling": "NATIVE",
        "descending": true,
        "ascending": false
    }
  ],
  "first": true,
  "number_of_elements": 2,
  "size": 25,
  "number": 2
}

Get the information for all transactions for an account. Transactions represent buy or sell orders for securities. Transaction records are created at a portfolio level and all transactions for each portfolio below an account are returned to show the account’s transaction activity. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view the accounts defined for your firm. The endpoint returns a list of transaction_ids and details for each transaction. See the Order section for more information. Additional parameters available to narrow down what is returned include a date range.

HTTP REQUEST

GET /account/{account_id}/transaction

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
id UUID The id for the transaction record
date date Date for when the transaction occurred
is_read boolean Indicates if the transaction has been read. Defaults to false which indicates it has not been read
portfolio_id UUID The id for the portfolio that the transaction falls under
model_id UUID The id for the model to which the portfolio that the transaction falls under subscribes
price double Price at which security was bought or sold included in the transaction
quantity double Quantity of shares of the security purchased
security_id UUID The id of the security included in the transaction
transaction_code_id UUID The id referring to the transaction code, defined by your firm
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the transaction record was created
update_date timestamp Timestamp for the date and time that the transaction record was last updated

Account Type

Accounts are assigned an account type based on the legal construct of the account. Examples include a “Roth IRA”, “ISA”, or “Revocable Trust.” Account types can be custom set by your firm based on those you accept.

Field Type Description
id UUID The id for the specific account type
name string Name of the account type such as Taxable or Joint
short_name string Abbreviated name for the account type
category string Category grouping that the account type falls under
subcategory string Subcategory grouping under the category that the account type falls under
code string Code defined by your firm for the specific account type
is_active boolean Indicates if his account type is active. Defaults to true which indicates it is active and available to be assigned to accounts
is_taxable boolean Indicates if this account type is taxable. true indicates it is taxable
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all account types

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_type"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all account types
    api_response = api_instance.get_account_types()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_types: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all account types
  result = api_instance.get_account_types()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_types: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountTypeResponse result = apiInstance.getAccountTypes();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountTypes");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountTypes(opts, callback);

Example Response

{
    "content": [
        {
            "id": "50d76212-0fcd-4d36-8633-e4a52cbcb79f",
            "create_date": "2018-04-13T14:24:43.000+0000",
            "update_date": "2018-04-13T14:24:43.000+0000",
            "category": "Custodial",
            "code": "101",
            "is_active": true,
            "is_taxable": true,
            "name": "Custodial",
            "short_name": "CUST",
            "metadata": {}
        },
        {
            "id": "cb94ee79-1ef4-4d67-9611-97a739523aeb",
            "create_date": "2018-04-13T14:24:43.000+0000",
            "update_date": "2018-04-13T14:24:43.000+0000",
            "category": "Retirement",
            "code": "102",
            "is_active": true,
            "is_taxable": false,
            "name": "Retirement",
            "short_name": "RETIR",
            "metadata": {}
        },
        {
            "id": "f80b5555-7503-4a28-bc4b-d05d62e0e733",
            "create_date": "2018-04-13T14:24:43.000+0000",
            "update_date": "2018-04-13T14:24:43.000+0000",
            "category": "Taxable",
            "code": "103",
            "is_active": true,
            "is_taxable": true,
            "name": "Taxable",
            "short_name": "TXB",
            "metadata": {}
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

List all account types defined for your firm. Use this endpoint to determine which account_type_id to assign to a new account.

HTTP REQUEST

GET /account_type

Create an account type

Example Request

curl -X POST -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
-d '{
        "category": "Taxable",
        "code": "103",
        "is_taxable": true,
        "name": "Taxable",
        "short_name": "TXB"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_type"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AccountTypePayload(category="Taxable",
      code="103",
      is_taxable=True,
      name="Taxable",
      short_name="TXB")

try:
    # Create an account type
    api_response = api_instance.post_account_type(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_account_type: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AccountTypePayload.new
payload.category = "Taxable"
payload.code = "103"
payload.is_taxable = true
payload.name = "Taxable"
payload.short_name = "TXB"

begin
  #Create an account type
  result = api_instance.post_account_type(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_account_type: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AccountTypePayload payload = new AccountTypePayload(category="Taxable",
    code="103",
    isTaxable=true,
    name="Taxable",
    shortName="TXB");
try {
    GetAccountTypeSubresponse result = apiInstance.postAccountType(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAccountType");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AccountTypePayload(category="Taxable",
      code="103",
      isTaxable=true,
      name="Taxable",
      shortName="TXB");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAccountType(payload, callback);

Example Response

{
    "id": "f80b5555-7503-4a28-bc4b-d05d62e0e733",
    "create_date": "2018-04-13T14:24:43.000+0000",
    "category": "Taxable",
    "code": "103",
    "is_taxable": true,
    "is_active": true,
    "name": "Taxable",
    "short_name": "TXB",
    "metadata": {}
}

Create a new account type for your firm. The name must be provided and it will default to active. The create_date will default to the current date. The endpoint returns the account_type_id used to manage the account type and to map the account type to an account.

HTTP REQUEST

POST /account_type

ARGUMENTS

Parameter Type Required Description
name string required Name of the account type such as “Taxable” or “Joint”
short_name string optional Abbreviated name for the account type
category string optional Category grouping that the account type falls under
subcategory string optional Subcategory grouping under the category that the account type falls under
code string optional Code defined by your firm for the account type
is_taxable boolean optional Indicates if this account type is taxable. true indicates it is taxable
is_active boolean optional Indicates if this account type is active. Defaults to true which indicates it is active and available to be assigned to accounts
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve an account type

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_type/cf80b5555-7503-4a28-bc4b-d05d62e0e733"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_type_id = 'cf80b5555-7503-4a28-bc4b-d05d62e0e733'

try:
    # Retrieve an account type
    api_response = api_instance.get_account_type(account_type_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_type: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_type_id = 'cf80b5555-7503-4a28-bc4b-d05d62e0e733'

begin
  #Retrieve an account type
  result = api_instance.get_account_type(account_type_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_type: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountTypeId = new UUID("cf80b5555-7503-4a28-bc4b-d05d62e0e733");
try {
    GetAccountTypeSubresponse result = apiInstance.getAccountType(accountTypeId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountType");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountTypeId = "cf80b5555-7503-4a28-bc4b-d05d62e0e733";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountType(accountTypeId, callback);

Example Response

{
    "id": "f80b5555-7503-4a28-bc4b-d05d62e0e733",
    "create_date": "2018-04-13T14:24:43.000+0000",
    "update_date": "2018-04-13T14:24:43.000+0000",
    "category": "Taxable",
    "code": "103",
    "is_active": true,
    "is_taxable": true,
    "short_name": "TXB",
    "name": "Taxable",
    "metadata": {}
}

Retrieve the information for an account type defined for your firm. The unique account_type_id must be provided. The endpoint returns the account_type_id and the details for the account type specified.

HTTP REQUEST

GET /account_type/{account_type_id}

Update an account type

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
-d '{
        "category": "Taxable",
        "code": "103",
        "is_active": true,
        "is_taxable": true,
        "short_name": "TXB",
        "name": "Taxable"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_type/f80b5555-7503-4a28-bc4b-d05d62e0e733"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_type_id = 'f80b5555-7503-4a28-bc4b-d05d62e0e733'
payload = atom_api.AccountTypePayload(category="Taxable",
  code="103",
  is_active=True,
  is_taxable=True,
  short_name="TXB",
  name="Taxable")

try:
    # Update an account type
    api_response = api_instance.update_account_type(account_type_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account_type: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_type_id = 'f80b5555-7503-4a28-bc4b-d05d62e0e733'

payload = AtomApi::AccountTypePayload.new
payload.category = "Taxable"
payload.code = "103"
payload.is_active = true
payload.is_taxable = true
payload.short_name = "TXB"
payload.name = "Taxable"

begin
  #Update an account type
  result = api_instance.update_account_type(account_type_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account_type: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountTypeId = new UUID("f80b5555-7503-4a28-bc4b-d05d62e0e733");
AccountTypePayload payload = new AccountTypePayload(category="Taxable",
    code="103",
    isActive=true,
    isTaxable=true,
    shortName="TXB",
    name="Taxable");
try {
    GetAccountTypeSubresponse result = apiInstance.updateAccountType(accountTypeId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccountType");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountTypeId = "f80b5555-7503-4a28-bc4b-d05d62e0e733";

var payload = new atom_api.AccountTypePayload(category="Taxable",
      code="103",
      isActive=true,
      isTaxable=true,
      shortName="TXB",
      name="Taxable");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccountType(accountTypeIdpayload, callback);

Example Response

{
    "id": "f80b5555-7503-4a28-bc4b-d05d62e0e733",
    "create_date": "2018-04-13T14:24:43.000+0000",
    "update_date": "2018-04-13T14:24:43.000+0000",
    "category": "Taxable",
    "code": "103",
    "is_active": true,
    "is_taxable": true,
    "short_name": "TXB",
    "name": "Taxable",
    "metadata": {}
}

Update the information for a possible account type defined for your firm. The unique account_type_id must be provided. To identify the appropriate account_type_id, use the GET /account_type endpoint to view all account types defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the information for the account_type_id including the updated details. Use this endpoint to mark an account type as inactive instead of deleting it permanently using the DELETE /account_type/{account_type_id} endpoint.

HTTP REQUEST

PUT /account_type/{account_type_id}

Delete an account type

Example Request

curl -X DELETE -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_type/f80b5555-7503-4a28-bc4b-d05d62e0e733"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_type_id = 'f80b5555-7503-4a28-bc4b-d05d62e0e733'

try:
    # Delete an account type
    api_instance.delete_account_type(account_type_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account_type: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_type_id = 'f80b5555-7503-4a28-bc4b-d05d62e0e733'

begin
  #Delete an account type
  api_instance.delete_account_type(account_type_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account_type: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountTypeId = new UUID("f80b5555-7503-4a28-bc4b-d05d62e0e733");
try {
    apiInstance.deleteAccountType(accountTypeId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccountType");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountTypeId = "f80b5555-7503-4a28-bc4b-d05d62e0e733";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccountType(accountTypeId, callback);

Response (204 No Content)

Permanently delete a possible account type defined for your firm. The unique account_type_id must be provided. To identify the appropriate account_type_id, use the GET /account_type endpoint to view all account types defined for your. This permanently deletes the account_type_id and associated information. To mark the account type as inactive without permanently deleting it, use the PUT /account_type/{account_type_id} endpoint to change the indicator for whether or not the account type is active to show that it is inactive.

HTTP REQUEST

DELETE /account_type/{account_type_id}

Account Stage

Account stages indicate what point an account is in along a user journey. The account stage is often used to provide business insights into the progression through a sign up funnel to track metrics such as drop-off, acquisition cost, and churn.

Field Type Description
id UUID The id of the account stage
name string Name or label of the account stage such as Pending Funding or Signed Up
description string Description of what the step along the registration process that the account stage represents
order_index integer Indicator for where along the process the account stage falls. Generally, the higher the order index, the further along the process
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all account stages

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/stage"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all account stages
    api_response = api_instance.get_account_stages()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_stages: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all account stages
  result = api_instance.get_account_stages()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_stages: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountStageResponse result = apiInstance.getAccountStages();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountStages");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountStages(opts, callback);

Example Response

{
    "content": [
        {
            "id": "099961da-7f41-4309-950f-2b51689a0033",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Started Application",
            "order_index": 3,
            "metadata": {}
        },
        {
            "id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Customized Allocation",
            "order_index": 2,
            "metadata": {}
        },
        {
            "id": "2a7a6cb7-ef71-4fe8-9169-2678f3799657",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Funding Submitted",
            "order_index": 6,
            "metadata": {}
        },
        {
            "id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Signed Up",
            "order_index": 1,
            "metadata": {}
        },
        {
            "id": "a65929b6-b0a9-46e5-858a-121f0b10f4fb",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Application Accepted",
            "order_index": 5,
            "metadata": {}
        },
        {
            "id": "bab849d6-de96-4dc7-a5ea-19be45c52a4e",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Funding in Progress",
            "order_index": 7,
            "metadata": {}
        },
        {
            "id": "e995d4c1-f989-4733-9867-713966ac9856",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Funded & Awaiting Investment",
            "order_index": 8,
            "metadata": {}
        },
        {
            "id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Application Submitted",
            "order_index": 4,
            "metadata": {}
        },
        {
            "id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Converted",
            "order_index": 9,
            "metadata": {}
        },
        {
            "id": "feb846da-a06d-402e-a3bb-abc7260f7138",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "name": "Closed",
            "order_index": 10,
            "metadata": {}
        }
    ],
    "last": true,
    "total_pages": 1,
    "total_elements": 10,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 10,
    "size": 25,
    "number": 0
}

Get the information for all possible account stages defined by your firm that can be assigned to accounts.

HTTP REQUEST

GET /stage

Create an account stage

Example Request

curl -X POST -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    -H "Content-Type: application/json" \
    -d '{
            "name": "Signed Up",
            "order_index": 1
        }' "https://api.hydrogenplatform.com/nucleus/v1/stage"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AccountStagePayload(name="Signed Up",
    order_index=1)

try:
    # Create an account stage
    api_response = api_instance.post_account_stage(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_account_stage: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AccountStagePayload.new
payload.name = "Signed Up"
payload.order_index = 1

begin
  #Create an account stage
  result = api_instance.post_account_stage(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_account_stage: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AccountStagePayload payload = new AccountStagePayload(name="Signed Up",
    orderIndex=1);
try {
    SpecificAccountStageResponse result = apiInstance.postAccountStage(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAccountStage");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AccountStagePayload(name="Signed Up",
    orderIndex=1);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAccountStage(payload, callback);

Example Response

{
    "id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "name": "Signed Up",
    "order_index": 1,
    "metadata": {}
}

Create and define an account stage that can subsequently be assigned to accounts. The name and description for the account stage must be provided. The endpoint returns the stage_id used to assign the stage to accounts.

HTTP REQUEST

POST /stage

ARGUMENTS

Parameter Type Required Description
name string required Name or label of the account stage such as “Pending Funding” or “Fully Funded”
description string optional Description of what the step along the registration process that the account stage represents
order_index integer optional Indicator for where along the process the account stage falls. Generally, the higher the order index, the further along the process
secondary_id string optional Alternate id that can be used to identify the object such as an internal id
metadata map optional Custom information associated with the entity in the format key:value
See Metadata

Retrieve an account stage

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/stage/647c54c3-b649-477e-8cc7-eee56a120dd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'

try:
    # Retrieve an account stage
    api_response = api_instance.get_account_stage(stage_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_stage: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'

begin
  #Retrieve an account stage
  result = api_instance.get_account_stage(stage_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_stage: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID stageId = new UUID("647c54c3-b649-477e-8cc7-eee56a120dd3");
try {
    SpecificAccountStageResponse result = apiInstance.getAccountStage(stageId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountStage");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var stageId = "647c54c3-b649-477e-8cc7-eee56a120dd3";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountStage(stageId, callback);

Example Response

{
    "id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "update_date": "2018-02-08T16:59:27.000+0000",
    "name": "Signed Up",
    "order_index": 1,
    "metadata": {}
}

Retrieve the information for a specific account stage that can be assigned to accounts. The unique stage_id must be provided. To obtain the appropriate stage_id, use the GET /stage endpoint to view all stages defined by your firm. The endpoint returns the account stage’s description and name.

HTTP REQUEST

GET /stage/{stage_id}

Update an account stage

Example Request

curl -X PUT -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    -H "Content-Type: application/json" \
    -d '{
            "name": "Signed Up",
            "description": "Initial information provided and client created",
            "order_index": 1
        }' "https://api.hydrogenplatform.com/nucleus/v1/stage/647c54c3-b649-477e-8cc7-eee56a120dd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'
payload = atom_api.AccountStagePayload(name="Signed Up",
   description="Initial information provided and client created",
   order_index=1)

try:
    # Update an account stage
    api_response = api_instance.update_account_stage(stage_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account_stage: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'

payload = AtomApi::AccountStagePayload.new
payload.name = "Signed Up"
payload.description = "Initial information provided and client created"
payload.order_index = 1

begin
  #Update an account stage
  result = api_instance.update_account_stage(stage_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account_stage: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID stageId = new UUID("647c54c3-b649-477e-8cc7-eee56a120dd3");
AccountStagePayload payload = new AccountStagePayload(name="Signed Up",
      description="Initial information provided and client created",
      orderIndex=1);
try {
    SpecificAccountStageResponse result = apiInstance.updateAccountStage(stageId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccountStage");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var stageId = "647c54c3-b649-477e-8cc7-eee56a120dd3";

var payload = new atom_api.AccountStagePayload(name="Signed Up",
   description="Initial information provided and client created",
   orderIndex=1);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccountStage(stageIdpayload, callback);

Example Response

{
    "id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "update_date": "2018-02-08T16:59:27.000+0000",
    "name": "Signed Up",
    "description": "Initial information provided and client created",
    "order_index": 1,
    "metadata": {}
}

Update the information for an account stage. The unique stage_id must be provided. To obtain the appropriate stage_id, use the GET /stage endpoint to view all stages defined by your firm and their current information. The stage’s new description and name must also be provided. The endpoint returns the stage_id and details for the account stage.

HTTP REQUEST

PUT /stage/{stage_id}

Delete an account stage

Example Request

curl -X DELETE -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/stage/647c54c3-b649-477e-8cc7-eee56a120dd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'

try:
    # Delete an account stage
    api_instance.delete_account_stage(stage_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account_stage: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

stage_id = '647c54c3-b649-477e-8cc7-eee56a120dd3'

begin
  #Delete an account stage
  api_instance.delete_account_stage(stage_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account_stage: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID stageId = new UUID("647c54c3-b649-477e-8cc7-eee56a120dd3");
try {
    apiInstance.deleteAccountStage(stageId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccountStage");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var stageId = "647c54c3-b649-477e-8cc7-eee56a120dd3";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccountStage(stageId, callback);

Response (204 No Content)

Permanently delete an account stage. The unique stage_id must be provided. To obtain the appropriate stage_id, use the GET /stage endpoint to view all stages defined by your firm. This deletes the stage_id and the stage will no longer be able to be assigned to an account as their account status

HTTP REQUEST

DELETE /stage/{stage_id}

Account Status

Account statuses correspond to a stage_id and reflects the different stages that an account flows through along a user journey, useful for sign-up funnels. See the account stage section for stage_ids.

Field Type Description
id UUID The id for the specific account status record for the account_id provided
account_id UUID The id of the account to which the status belongs
status string Status of the account such as “Signed Up” or “Awaiting Payment”
stage_id UUID Refers to the stage the client is in.
Useful for sign-up funnels
comments string Comments for the client regarding the status of their account
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all account statuses

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_status"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all account statuses
    api_response = api_instance.get_account_statuses()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_statuses: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all account statuses
  result = api_instance.get_account_statuses()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_statuses: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountStatusResponse result = apiInstance.getAccountStatuses();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountStatuses");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountStatuses(opts, callback);

Example Response

{
    "content": [
        {
            "id": "6db4a470-a00c-40bb-a325-067d0bdb3ddc",
            "create_date": "2018-02-08T16:59:27.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "comments": "Invested",
            "status": "Complete",
            "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
            "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
            "metadata": {}
        },
        {
            "id": "013380bf-7f17-44c1-93c5-892a7ed3498c",
            "create_date": "2017-04-07T00:00:00.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "status": "",
            "stage_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
            "account_id": "21098ed9-6439-46ba-abd9-eb6cf28866fb",
            "metadata": {}
        },
        {
            "id": "01b252d3-1412-477f-8d29-6e2ff6e54c81",
            "create_date": "2017-10-05T00:00:00.000+0000",
            "update_date": "2018-02-08T16:59:27.000+0000",
            "status": "",
            "stage_id": "2a7a6cb7-ef71-4fe8-9169-2678f3799657",
            "account_id": "4ff21db3-97ab-4bbd-9885-be6aec522c44",
            "metadata": {}
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0

Get the account status history information for all accounts defined for your firm. Account status corresponds to a stage_id and reflects the different stages of a user journey, useful in sign-up funnels. You can filter using a unique account_id to view the account_status records for a specific account. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm.

HTTP REQUEST

GET /account_status

Create an account status

Example Request

curl -X POST -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
-H "Content-Type: application/json" \
-d '{
        "comments": "Invested",
        "status": "Complete",
        "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
        "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_status"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AccountStatusPayload(comments="Invested",
    status="Complete",
    stage_id="e995d4c1-f989-4733-9867-713966ac9856",
    account_id="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7")

try:
    # Create an account status
    api_response = api_instance.post_account_status(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_account_status: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AccountStatusPayload.new
payload.comments = "Invested"
payload.status = "Complete"
payload.stage_id = "e995d4c1-f989-4733-9867-713966ac9856"
payload.account_id = "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7"

begin
  #Create an account status
  result = api_instance.post_account_status(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_account_status: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AccountStatusPayload payload = new AccountStatusPayload(comments="Invested",
    status="Complete",
    stageId="e995d4c1-f989-4733-9867-713966ac9856",
    accountId="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7");
try {
    CreateAccountStatusResponse result = apiInstance.postAccountStatus(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAccountStatus");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AccountStatusPayload(comments="Invested",
    status="Complete",
    stageId="e995d4c1-f989-4733-9867-713966ac9856",
    accountId="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAccountStatus(payload, callback);

Example Response

{
    "id": "6db4a470-a00c-40bb-a325-067d0bdb3ddc",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "comments": "Invested",
    "status": "Complete",
    "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
    "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
    "metadata": {}
}

Create an account status record for an account by assigning a stage_id to the account. The unique account_id and stage_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm. To obtain the appropriate stage_id, use the GET /stage endpoint to view all account stages defined for your firm. The create_date defaults to the current date. The endpoint returns an account_status_id which represents a record in the account’s history log.

HTTP REQUEST

POST /account_status

ARGUMENTS

Parameter Type Required Description
account_id UUID required The id of the account to which the status belongs
status string required Status of the account such as “Signed Up” or “Awaiting Payment”
stage_id UUID required Refers to the stage the client is in.
Useful for sign-up funnels
comments string optional Comments for the client regarding the status of their account
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve an account status

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_status/6db4a470-a00c-40bb-a325-067d0bdb3ddc"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'

try:
    # Retrieve an account status
    api_response = api_instance.get_account_status(account_status_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_status: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'

begin
  #Retrieve an account status
  result = api_instance.get_account_status(account_status_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_status: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountStatusId = new UUID("6db4a470-a00c-40bb-a325-067d0bdb3ddc");
try {
    SpecificAccountStatusResponse result = apiInstance.getAccountStatus(accountStatusId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountStatus");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountStatusId = "6db4a470-a00c-40bb-a325-067d0bdb3ddc";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountStatus(accountStatusId, callback);

Example Response

{
    "id": "6db4a470-a00c-40bb-a325-067d0bdb3ddc",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "update_date": "2018-02-08T16:59:27.000+0000",
    "comments": "Invested",
    "status": "Complete",
    "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
    "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
    "metadata": {}
}

Retrieve the information for a specific account status record for an account. The unique account_status_id must be provided. The endpoint returns details for the account status record specified.

HTTP REQUEST

GET /account_status/{account_status_id}

Update an account status

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
-H "Content-Type: application/json" \
-d '{
        "comments": "Invested",
        "status": "Complete",
        "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
        "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_status/6db4a470-a00c-40bb-a325-067d0bdb3ddc"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'
payload = atom_api.AccountStatusPayload(comments="Invested",
    status="Complete",
    stage_id="e995d4c1-f989-4733-9867-713966ac9856",
    account_id="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7")

try:
    # Update an account status
    api_response = api_instance.update_account_status(account_status_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account_status: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'

payload = AtomApi::AccountStatusPayload.new
payload.comments = "Invested"
payload.status = "Complete"
payload.stage_id = "e995d4c1-f989-4733-9867-713966ac9856"
payload.account_id = "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7"

begin
  #Update an account status
  result = api_instance.update_account_status(account_status_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account_status: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountStatusId = new UUID("6db4a470-a00c-40bb-a325-067d0bdb3ddc");
AccountStatusPayload payload = new AccountStatusPayload(comments="Invested",
    status="Complete",
    stageId="e995d4c1-f989-4733-9867-713966ac9856",
    accountId="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7");
try {
    SpecificAccountStatusResponse result = apiInstance.updateAccountStatus(accountStatusId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccountStatus");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountStatusId = "6db4a470-a00c-40bb-a325-067d0bdb3ddc";

var payload = new atom_api.AccountStatusPayload(comments="Invested",
    status="Complete",
    stageId="e995d4c1-f989-4733-9867-713966ac9856",
    accountId="1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccountStatus(accountStatusIdpayload, callback);

Example Response

{
    "id": "6db4a470-a00c-40bb-a325-067d0bdb3ddc",
    "create_date": "2018-02-08T16:59:27.000+0000",
    "update_date": "2018-02-08T16:59:27.000+0000",
    "comments": "Invested",
    "status": "Complete",
    "stage_id": "e995d4c1-f989-4733-9867-713966ac9856",
    "account_id": "1d7e1aad-3c79-49fe-bbb9-bd5e239ae1e7",
    "metadata": {}
}

Update an account status record for an account. The unique account_status_id must be provided. To obtain the appropriate account_status_id, use the GET /account_status endpoint to view all account statuses for each account defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the account_status_id with the details for the account status.

HTTP REQUEST

PUT /account_status/{account_status_id}

Delete an account status

Example Request

curl -X DELETE -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_status/6db4a470-a00c-40bb-a325-067d0bdb3ddc"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'

try:
    # Delete an account status
    api_instance.delete_account_status(account_status_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account_status: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_status_id = '6db4a470-a00c-40bb-a325-067d0bdb3ddc'

begin
  #Delete an account status
  api_instance.delete_account_status(account_status_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account_status: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountStatusId = new UUID("6db4a470-a00c-40bb-a325-067d0bdb3ddc");
try {
    apiInstance.deleteAccountStatus(accountStatusId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccountStatus");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountStatusId = "6db4a470-a00c-40bb-a325-067d0bdb3ddc";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccountStatus(accountStatusId, callback);

Response (204 No Content)

Permanently delete an account status record from an account’s history. The account_status_id must be provided. To obtain the appropriate account_status_id, use the GET /account_status endpoint to view all account statuses for each account defined for your firm. This deletes the account_status_id from the account’s history log table and removes the status from the account.

HTTP REQUEST

DELETE /account_status/{account_status_id}

Account Permission

The Account Permission endpoints vary slightly from other Nucleus endpoints as they are not used to manage specific objects, but rather to manage the permission type of a client to an account. All of the authorities except the ROLE_CLIENT authority can access these endpoints.

Field Type Description
account_id UUID The id of the account being granted permissions
clients array List of clients mapped to the account and their permission type
      client_id UUID The id of the client being granted permissions to the account. Must also be included in the clients.client_id field of the account
      permission_type string The permission type for the client. Available values are INQUIRY_ACCESS, LIMTIED_AUTHORITY, FULL_AUTHORITY, and POWER_OF_ATTORNEY. Please view the Permission Type resource for more information on each authority. To view what endpoints each authority permissions, please see this guide
       acl_exist boolean Indicator used for existing clients mapped to an account (upon implementation) in the database to indicate if permissioning has been applied for them. true indicates it has. After implementation of data access controls, this field would no longer be necessary

List all account permissions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_permission"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all account permissions
    api_response = api_instance.get_account_permissions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_permissions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all account permissions
  result = api_instance.get_account_permissions()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_permissions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAccountPermissionsResponse result = apiInstance.getAccountPermissions();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountPermissions");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountPermissions(opts, callback);

Example Response

{
    "content": [
        {
            "account_id": "6fca8ba0-d7e6-42cb-863d-a0f9f794ced5",
            "clients": [
                {
                    "permission_type": "FULL_AUTHORITY",
                    "client_id": "6e8e1cbd-c52d-4be7-a466-b00863999b2c",
                    "acl_exist": true
                },
                {
                    "permission_type": "INQUIRY_ACCESS",
                    "client_id": "4358f699-8563-46f7-aff4-9817c30ac907",
                    "acl_exist": true
                }
            ]
        },
        {
            "account_id": "3db529a2-bab7-4ecf-8b7f-bb738a2ed371",
            "clients": [
                {
                    "permission_type": "FULL_AUTHORITY",
                    "client_id": "4358f699-8563-46f7-aff4-9817c30ac907",
                    "acl_exist": true
                }
            ]
        }
    ],
    "total_elements": 2,
    "total_pages": 1,
    "last": true,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": false,
            "descending": true
        }
    ],
    "number_of_elements": 2,
    "size": 25,
    "number": 0
}

Get the clients and permission types for all accounts defined for your firm. Account permissions control the actions that a client can take on an account. Only clients with the authority of ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, or ROLE_ADVISOR can access this endpoint.

HTTP REQUEST

GET /account_permission

Retrieve an account’s permissions

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_permission/f446662e-042d-4a65-b528-f7b8353fb67e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'

try:
    # Retrieve an account's permission
    api_response = api_instance.get_account_permission(account_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_account_permission: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'

begin
  #Retrieve an account's permission
  result = api_instance.get_account_permission(account_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_account_permission: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("f446662e-042d-4a65-b528-f7b8353fb67e");
try {
    SpecificAccountPermissionResponse result = apiInstance.getAccountPermission(accountId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAccountPermission");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAccountPermissions(opts, callback);

Example Response

{
    "account_id": "f446662e-042d-4a65-b528-f7b8353fb67e",
    "clients": [
        {
            "permission_type": "LIMITED_AUTHORITY",
            "client_id": "5c13bf69-3331-417a-bce7-88f8172363b5",
            "acl_exist": true
        }
    ]
}

Retrieve all the clients and their permission type for a specific account. Only clients with the authority of ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, or ROLE_ADVISOR can access this endpoint.

HTTP REQUEST

GET /account_permission/{account_id}

Update an account’s permissions

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
-H "Content-Type: application/json" \
-d '{
        "client_id": "I5c13bf69-3331-417a-bce7-88f8172363b5",
        "permission_type": "LIMITED_AUTHORITY"
    }' "https://api.hydrogenplatform.com/nucleus/v1/account_permission/f446662e-042d-4a65-b528-f7b8353fb67e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'
payload = atom_api.AccountPermissionPayload(client_id="I5c13bf69-3331-417a-bce7-88f8172363b5",
                                            permission_type="LIMITED_AUTHORITY")

try:
    # Update an account's permissions
    api_response = api_instance.update_account_permission(account_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_account_permission: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'

payload = AtomApi::AccountPermissionPayload.new
payload.client_id = "I5c13bf69-3331-417a-bce7-88f8172363b5"
payload.permission_type = "LIMITED_AUTHORITY"

begin
  #Update an account's permissions
  result = api_instance.update_account_permission(account_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_account_permission: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("f446662e-042d-4a65-b528-f7b8353fb67e");
AccountPermissionPayload payload = new AccountPermissionPayload(clientId="I5c13bf69-3331-417a-bce7-88f8172363b5",
                                                                permissionType="LIMITED_AUTHORITY");
try {
    SpecificAccountPermissionResponse result = apiInstance.updateAccountPermission(accountId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAccountPermission");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "f446662e-042d-4a65-b528-f7b8353fb67e";

var payload = new atom_api.AccountPermissionPayload(clientId="I5c13bf69-3331-417a-bce7-88f8172363b5",
    permissionType="LIMITED_AUTHORITY");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAccountPermission(accountIdpayload, callback);

Example Response

{
    "account_id": "f446662e-042d-4a65-b528-f7b8353fb67e",
    "clients": [
        {
            "permission_type": "LIMITED_AUTHORITY",
            "client_id": "5c13bf69-3331-417a-bce7-88f8172363b5",
            "acl_exist": true
        }
    ]
}

Update the permission type of a client for an account. When a client_id is included in the clients embedded object of a call to the POST /account and PUT /account/{account_id} endpoints, they will automatically be mapped to the account with a permission type based on the client_account_association_type granted to them. If you would like the user to have a different permission type, you can use this endpoint to change it. The account_id is specified in the URL, and the client_id and the updated permission type must be provided in the request body. Only clients with the authority of ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, or ROLE_ADVISOR can access this endpoint.

HTTP REQUEST

PUT /account_permission/{account_id}

ARGUMENTS

Parameter Type Required Description
clients array optional List of clients mapped to the account and their permission type
      client_id UUID required The id of the client being granted permissions to the account. Must also be included in the clients.client_id field of the account
      permission_type string required The permission type for the client. Available values are INQUIRY_ACCESS, LIMTIED_AUTHORITY, FULL_AUTHORITY, and POWER_OF_ATTORNEY. Please view the Permission Type resource for more information on each authority. To view what endpoints each authority permissions, please see this guide
       acl_exist boolean optional Indicator used for existing clients mapped to an account (upon implementation) in the database to indicate if permissioning has been applied for them. true indicates it has. After implementation of data access controls, this field would no longer be necessary

Delete an account’s permissions

Example Request

curl -X DELETE -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/account_permission/f446662e-042d-4a65-b528-f7b8353fb67e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'

try:
    # Delete an account's permissions
    api_instance.delete_account_permission(account_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_account_permission: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

account_id = 'f446662e-042d-4a65-b528-f7b8353fb67e'

begin
  #Delete an account's permissions
  api_instance.delete_account_permission(account_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_account_permission: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID accountId = new UUID("f446662e-042d-4a65-b528-f7b8353fb67e");
try {
    apiInstance.deleteAccountPermission(accountId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAccountPermission");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var accountId = "f446662e-042d-4a65-b528-f7b8353fb67e";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAccountPermission(accountId, callback);

Response (204 No Content)

Permanently delete the permissions of an account. The account_id must be provided in the URL. This removes all the clients mapped to the account and their permission types. Only clients with the authority of ROLE_SUPER_ADMIN, ROLE_ADMIN, ROLE_PORTFOLIO_MANAGER, ROLE_MARKETING_MANAGER, ROLE_OPERATIONS, ROLE_SUPPORT, or ROLE_ADVISOR can access this endpoint.

HTTP REQUEST

DELETE /account_permission/{account_id}

Client

Clients represent users (both internal and external users) of your firm’s platform and are critical to further set-ups. For example, accounts are created below clients.

Field Type Description
id UUID The id of the client
username string Username for the client used on the firm’s platform
client_type string Defined client type for the client. Available client types are individual, firm, admin, and advisor, all case sensitive
email string Contact email for the client in the format [email protected]
title string The title of the client such as “Mr.”, “Ms.”, “Miss”, “Mx.”, etc.
first_name string First name or given name of the client
middle_name string Middle name of the client
last_name string Last name or surname of the client
phone_number string Phone number associated with the client
date_of_birth date Date of birth of the client in the ISO 8601 format YYYY-MM-DD
identification_number string National or local identification number for a client such as Social Security Number, frequently used for Know-Your-Customer (KYC) purposes
country_of_residence string The country of residence of a client, often corresponding to the country issuing the identification number provided above using the ISO ALPHA-2 Code, frequently used for Know-Your-Customer (KYC) purposes. See country codes
income integer The total income for the client
is_verified boolean Indicator for whether or not the identifying details provided by the client have been verified by a Know-Your-Customer (KYC) vendor. Defaults to false which indicates it is not verified
hydro_id string The Hydro ID associated with the client (if applicable). Corresponds to the Client Hydro entity
is_active boolean Indicates if the client is currently active. Defaults to true which indicates it is active
address array Address details for the client
      address_line1 string Primary information for the street address, such as the street and building number
      address_line2 string Secondary information for the street address, such as a suite or apartment number
      city string City for the address
      state string State, province, or sub-country region for the address
      postalcode string Alphanumeric postal code or zip code for the address
      country string Country for the address using the ISO ALPHA-2 Code. See country codes
      type string Type of address such as “home”, “work”, “billing”, “mailing”, etc. This is used to differentiate between multiple addresses provided
metadata map Custom information associated with the client in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Client Management

List all clients

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all clients
    api_response = api_instance.get_clients()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_clients: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all clients
  result = api_instance.get_clients()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_clients: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetClientResponse result = apiInstance.getClients();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClients");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClients(opts, callback);

Example Response

{
    "content": [
      {
        "id": "099961da-7f41-4309-950f-2b51689a0033",
        "create_date": "2017-01-03T00:00:00.000+0000",
        "update_date": "2018-02-23T18:29:09.000+0000",
        "email": "[email protected]",
        "username": "[email protected]",
        "client_type": "individual",
        "title": "Mrs.",
        "first_name": "Jane",
        "middle_name": "Mary",
        "last_name": "Doe",
        "phone_number": "987-765-1244",
        "date_of_birth": "1971-12-27",
        "identification_number": "123-44-5566",
        "country_of_residence": "US",
        "income": 70000,
        "is_verified": true,
        "hydro_id": "10lm4nz",
        "is_active": true,
        "metadata": {
          "median_household_income": "10000",
          "net_worth": "100000",
          "occupation": "Business Owner",
          "zillow_home_value": "450000",
          "annual_income": "70000"
        },
        "address": [
          {
              "address_line1": "3 Downtown Street",
              "address_line2": "",
              "city": "New York",
              "type": "Home",
              "postalcode": "01191",
              "country": "US",
              "state": "NY"
          }
        ]
      },
      {
        "id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
        "secondary_id": "234892384",
        "create_date": "2017-01-09T00:00:00.000+0000",
        "update_date": "2018-02-23T18:29:09.000+0000",
        "email": "[email protected]",
        "username": "advisor1",
        "client_type": "advisor",
        "title": "Mrs.",
        "first_name": "Marie",
        "last_name": "Baker",
        "date_of_birth": "1987-12-23",
        "is_active": true,
        "metadata": {
            "median_household_income": "10000",
            "net_worth": "550000",
            "occupation": "Service",
            "zillow_home_value": "450000",
            "annual_income": "80000"
        },
        "address": [
            {
                "address_line1": "9 Main Street",
                "address_line2": "",
                "city": "New York9",
                "type": "Home",
                "postalcode": "99999",
                "country": "US",
                "state": "WY"
            }
        ]
      },
      {
          "id": "04907eaa-3f33-49be-a35b-378cdf639fba",
          "create_date": "2017-04-03T00:00:00.000+0000",
          "update_date": "2018-02-23T18:29:09.000+0000",
          "email": "[email protected]",
          "username": "andrewl",
          "title": "Mr.",
          "first_name": "Andrew",
          "last_name": "Lewelz",
          "phone_number": "234-566-7788",
          "date_of_birth": "1993-12-21",
          "income": 85000,
          "client_type": "individual",
          "is_active": true,
          "metadata": {
              "median_household_income": "70000",
              "net_worth": "400000",
              "occupation": "Information Systems",
              "zillow_home_value": "425000",
              "annual_income": "180000"
          },
          "address": [
              {
                  "address_line1": "93 Main Street",
                  "address_line2": "",
                  "city": "New York",
                  "type": "Home",
                  "postalcode": "100001",
                  "country": "US",
                  "state": "NY"
              }
          ]
      }
    ],
    "total_pages": 1,
    "total_elements": 3,
    "last": false,
    "number_of_elements": 25,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "size": 25,
    "number": 0
}

Get details for all clients registered with your firm. Note that the address information and the metadata information are nested objects within the client object.

HTTP REQUEST

GET /client

Create a client

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d '{
            "email": "[email protected]",
            "username": "[email protected]",
            "client_type": "individual",
            "title": "Mrs.",
            "first_name": "Jane",
            "middle_name": "Mary",
            "last_name": "Doe",
            "phone_number": "987-765-1244",
            "date_of_birth": "1971-12-27",
            "identification_number": "123-44-5566",
            "country_of_residence": "US",
            "income": 70000,
            "is_verified": true,
            "hydro_id": "10lm4nz",
            "is_active": true,
            "metadata": {
                "median_household_income": "10000",
                "net_worth": "100000",
                "occupation": "Business Owner",
                "zillow_home_value": "450000",
                "annual_income": "70000"
            },
            "address": [
                {
                    "address_line1": "3 Downtown Street",
                    "address_line2": "",
                    "city": "New York",
                    "type": "Home",
                    "postalcode": "01191",
                    "country": "US",
                    "state": "NY"
                }
            ]
        }' "https://api.hydrogenplatform.com/nucleus/v1/client"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

address = atom_api.Address(address_line1="3 Downtown Street",
   address_line2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY")

payload = atom_api.ClientPayload(email="[email protected]",
   username="[email protected]",
   client_type="individual",
   title="Mrs.",
   first_name="Jane",
   middle_name="Mary",
   last_name="Doe",
   phone_number="987-765-1244",
   date_of_birth="1972-12-27",
   identification_number="123-44-5566",
   country_of_residence="US",
   is_verified=True,
   hydro_id="10lm4nz",
   is_active=True,
   metadata={
            "median_household_income": "10000",
            "net_worth": "100000",
            "occupation": "Business Owner",
            "zillow_home_value": "450000",
            "annual_income": "70000"
            },
   address=[address])

try:
    # Create a client
    api_response = api_instance.post_client(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_client: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::ClientPayload.new
payload.email = "[email protected]"
payload.username = "[email protected]"
payload.client_type = "individual"
payload.title = "Mrs."
payload.first_name = "Jane"
payload.middle_name = "Mary"
payload.last_name = "Doe"
payload.phone_number = "987-765-1244"
payload.date_of_birth = "1972-12-27"
payload.identification_number = "123-44-5566"
payload.country_of_residence = "US"
payload.is_verified = true
payload.hydro_id = "10lm4nz"
payload.is_active = true
payload.metadata = {median_household_income => "10000",
    net_worth => "100000",
    occupation => "Business Owner",
    zillow_home_value => "70000"}

address = AtomApi::Address.new
address.address_line1 = "3 Downtown Street"
address.address_line_2 = ""
address.city = "New York"
address.type = "Home"
address.postalcode = "01191"
address.country = "US"
address.state = "NY"
payload.address = [address]

begin
  #Create a client
  result = api_instance.post_client(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_client: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
Address addr = new Address(addressLine1="3 Downtown Street",
   addressLine2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY");
ClientPayload payload = new ClientPayload(email="[email protected]",
    username="[email protected]",
    clientType="individual",
    title="Mrs.",
    firstName="Jane",
    middleName="Mary",
    lastName="Doe",
    phoneNumber="987-765-1244",
    dateOfBirth="1972-12-27",
    identificationNumber="123-44-5566",
    countryOfResidence="US",
    isVerified=true,
    hydroId="10lm4nz",
    isActive=true,
    metadata={"median_household_income": "10000",
              "net_worth": "100000",
              "occupation": "Business Owner",
              "zillow_home_value": "70000"},
    address=[addr]);
try {
    CreateClientResponse result = apiInstance.postClient(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postClient");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var addr = new Address(addressLine1="3 Downtown Street",
   addressLine2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY");
var payload = new atom_api.ClientPayload(email="[email protected]",
   username="[email protected]",
   clientType="individual",
   title="Mrs.",
   firstName="Jane",
   middleName="Mary",
   lastName="Doe",
   phoneNumber="987-765-1244",
   dateOfBirth="1972-12-27",
   identificationNumber="123-44-5566",
   countryOfResidence="US",
   isVerified=true,
   hydroId="10lm4nz",
   isActive=true,
   metadata={"median_household_income": "10000",
             "net_worth": "100000",
             "occupation": "Business Owner",
             "zillow_home_value": "70000"},
   address=[addr]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postClient(payload, callback);

Example Response

{
    "id": "099961da-7f41-4309-950f-2b51689a0033",
    "create_date": "2017-01-03T00:00:00.000+0000",
    "email": "[email protected]",
    "username": "[email protected]",
    "client_type": "individual",
    "title": "Mrs.",
    "first_name": "Jane",
    "middle_name": "Mary",
    "last_name": "Doe",
    "phone_number": "987-765-1244",
    "date_of_birth": "1971-12-27",
    "identification_number": "123-44-5566",
    "country_of_residence": "US",
    "income": 70000,
    "is_verified": true,
    "hydro_id": "10lm4nz",
    "is_active": true,
    "metadata": {
        "median_household_income": "10000",
        "net_worth": "100000",
        "occupation": "Business Owner",
        "zillow_home_value": "450000",
        "annual_income": "70000"
    },
    "address": [
        {
            "address_line1": "3 Downtown Street",
            "address_line2": "",
            "city": "New York",
            "type": "Home",
            "postalcode": "01191",
            "country": "US",
            "state": "NY"
        }
    ]
}

Create a new client, or register a new user, with your firm. The create_date will default to the current date. The endpoint returns a unique client_id that is used to manage the specific client and referenced in other endpoints.

HTTP REQUEST

POST /client

ARGUMENTS

Parameter Type Required Description
username string required Username for the client used on the firm’s platform
client_type string required Defined client type for the client. Available client types are individual, firm, admin, and advisor, all case sensitive
email string optional Contact email for the client in the format [email protected]
title string optional The title of the client such as “Mr.”, “Ms.”, “Miss”, “Mx.”, etc.
first_name string optional First name or given name of the client
middle_name string optional Middle name of the client
last_name string optional Last name or surname of the client
phone_number string optional Phone number associated with the client
date_of_birth date optional Date of birth of the client in the ISO 8601 format YYYY-MM-DD
identification_number string optional National or local identification number for a client such as Social Security Number, frequently used for Know-Your-Customer (KYC) purposes
country_of_residence string optional The country of residence of a client, often corresponding to the country issuing the identification number provided above using the ISO ALPHA-2 Code, frequently used for Know-Your-Customer (KYC) purposes. See country codes
income integer optional The total income for the client
is_verified boolean optional Indicator if the identifying details provided by the client have been verified by a Know-Your-Customer (KYC) vendor. Defaults to false which indicates it is not verified
hydro_id string optional The Hydro ID associated with the client (if applicable). Corresponds to the Client Hydro entity
is_active boolean optional Indicates if the client is currently active. Defaults to true which indicates it is active
address array optional Address details for the client
      address_line1 string required Primary information for the street address, such as the street and building number
      address_line2 string optional Secondary information for the street address, such as a suite or apartment number
      city string required City for the address
      state string required State, province, or sub-country region for the address
      postalcode string optional Alphanumeric postal code or zip code for the address
      country string required Country for the address using the ISO ALPHA-2 Code. See country codes
      type string required Type of address such as “home”, “work”, “billing”, “mailing”, etc. This is used to differentiate between multiple addresses provided
metadata map optional Custom information associated with the client in the format key:value.
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a client

Retrieve the information for a client registered with your firm. The unique client_id must be provided. The endpoint returns the client_id and the details for the client. Note that the address information and the metadata information are nested objects within the client object.

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'

try:
    # Retrieve a client
    api_response = api_instance.get_client(client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

begin
  #Retrieve a client
  result = api_instance.get_client(client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
try {
    SpecificClientResponse result = apiInstance.getClient(clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClient");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClient(clientId, , callback);

Example Response

{
    "id": "099961da-7f41-4309-950f-2b51689a0033",
    "create_date": "2017-01-03T00:00:00.000+0000",
    "update_date": "2018-02-23T18:29:09.000+0000",
    "email": "[email protected]",
    "username": "[email protected]",
    "client_type": "individual",
    "title": "Mrs.",
    "first_name": "Jane",
    "middle_name": "Mary",
    "last_name": "Doe",
    "phone_number": "987-765-1244",
    "date_of_birth": "1971-12-27",
    "identification_number": "123-44-5566",
    "country_of_residence": "US",
    "income": 70000,
    "is_verified": true,
    "hydro_id": "10lm4nz",
    "is_active": true,
    "metadata": {
        "median_household_income": "10000",
        "net_worth": "100000",
        "occupation": "Business Owner",
        "zillow_home_value": "450000",
        "annual_income": "70000"
    },
    "address": [
        {
            "address_line1": "3 Downtown Street",
            "address_line2": "",
            "city": "New York",
            "type": "Home",
            "postalcode": "01191",
            "country": "US",
            "state": "NY"
        }
    ]
}

HTTP REQUEST

GET /client/{client_id}

Update a client

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d '{
            "email": "[email protected]",
            "username": "[email protected]",
            "client_type": "individual",
            "title": "Mrs.",
            "first_name": "Jane",
            "middle_name": "Mary",
            "last_name": "Doe",
            "phone_number": "987-765-1244",
            "date_of_birth": "1971-12-27",
            "identification_number": "123-44-5566",
            "country_of_residence": "US",
            "income": 70000,
            "is_verified": true,
            "hydro_id": "10lm4nz",
            "is_active": false,
            "metadata": {
                "median_household_income": "10000",
                "net_worth": "100000",
                "occupation": "Business Owner",
                "zillow_home_value": "450000",
                "annual_income": "70000"
            },
            "address": [
                {
                    "address_line1": "3 Downtown Street",
                    "address_line2": "",
                    "city": "New York",
                    "type": "Home",
                    "postalcode": "01191",
                    "country": "US",
                    "state": "NY"
            }
        ]
}' "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'
address = atom_api.Address(address_line1="3 Downtown Street",
   address_line2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY")

payload = atom_api.ClientPayload(email="[email protected]",
   username="[email protected]",
   client_type="individual",
   title="Mrs.",
   first_name="Jane",
   middle_name="Mary",
   last_name="Doe",
   phone_number="987-765-1244",
   date_of_birth="1972-12-27",
   identification_number="123-44-5566",
   country_of_residence="US",
   is_verified=True,
   hydro_id="10lm4nz",
   is_active=True,
   metadata={
            "median_household_income": "10000",
            "net_worth": "100000",
            "occupation": "Business Owner",
            "zillow_home_value": "450000",
            "annual_income": "70000"
            },
   address=[address])

try:
    # Update a client
    api_response = api_instance.update_client(client_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_client: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

payload = AtomApi::ClientPayload.new
payload.email = "[email protected]"
payload.username = "[email protected]"
payload.client_type = "individual"
payload.title = "Mrs."
payload.first_name = "Jane"
payload.middle_name = "Mary"
payload.last_name = "Doe"
payload.phone_number = "987-765-1244"
payload.date_of_birth = "1972-12-27"
payload.identification_number = "123-44-5566"
payload.country_of_residence = "US"
payload.is_verified = true
payload.hydro_id = "10lm4nz"
payload.is_active = true
payload.metadata = {median_household_income => "10000",
  net_worth => "100000",
  occupation => "Business Owner",
  zillow_home_value => "70000"}

address = AtomApi::Address.new
address.address_line1 = "3 Downtown Street"
address.address_line_2 = ""
address.city = "New York"
address.type = "Home"
address.postalcode = "01191"
address.country = "US"
address.state = "NY"
payload.address = [address]

begin
  #Update a client
  result = api_instance.update_client(client_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_client: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
Address addr = new Address(addressLine1="3 Downtown Street",
   addressLine2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY");
ClientPayload payload = new ClientPayload(email="[email protected]",
  username="[email protected]",
  clientType="individual",
  title="Mrs.",
  firstName="Jane",
  middleName="Mary",
  lastName="Doe",
  phoneNumber="987-765-1244",
  dateOfBirth="1972-12-27",
  identificationNumber="123-44-5566",
  countryOfResidence="US",
  isVerified=true,
  hydroId="10lm4nz",
  isActive=true,
  metadata={"median_household_income": "10000",
            "net_worth": "100000",
            "occupation": "Business Owner",
            "zillow_home_value": "70000"},
  address=[addr]);
try {
    SpecificClientResponse result = apiInstance.updateClient(clientId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateClient");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";
var addr = new Address(addressLine1="3 Downtown Street",
   addressLine2="",
   city="New York",
   type="Home",
   postalcode="01191",
   country="US",
   state="NY");

var payload = new atom_api.ClientPayload(email="[email protected]",
   username="[email protected]",
   clientType="individual",
   title="Mrs.",
   firstName="Jane",
   middleName="Mary",
   lastName="Doe",
   phoneNumber="987-765-1244",
   dateOfBirth="1972-12-27",
   identificationNumber="123-44-5566",
   countryOfResidence="US",
   isVerified=true,
   hydroId="10lm4nz",
   isActive=true,
   metadata={"median_household_income": "10000",
             "net_worth": "100000",
             "occupation": "Business Owner",
             "zillow_home_value": "70000"},
   address=[addr]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateClient(clientId, payload, callback);

Example Response

{
    "id": "099961da-7f41-4309-950f-2b51689a0033",
    "create_date": "2017-01-03T00:00:00.000+0000",
    "update_date": "2018-02-23T18:29:09.000+0000",
    "email": "[email protected]",
    "username": "[email protected]",
    "client_type": "individual",
    "title": "Mrs.",
    "first_name": "Jane",
    "middle_name": "Mary",
    "last_name": "Doe",
    "phone_number": "987-765-1244",
    "date_of_birth": "1971-12-27",
    "identification_number": "123-44-5566",
    "country_of_residence": "US",
    "income": 70000,
    "is_verified": true,
    "hydro_id": "10lm4nz",
    "is_active": false,
    "metadata": {
        "median_household_income": "10000",
        "net_worth": "100000",
        "occupation": "Business Owner",
        "zillow_home_value": "450000",
        "annual_income": "70000"
    },
    "address": [
        {
            "address_line1": "3 Downtown Street",
            "address_line2": "",
            "city": "New York",
            "type": "Home",
            "postalcode": "01191",
            "country": "US",
            "state": "NY"
        }
    ]
}

Update the information for a client registered with your firm. The unique client_id must be provided. To obtain the appropriate client_id, use the GET /client endpoint to view all available client_ids registered with your firm and their current information. The details to be updated must also be provided. The endpoint returns the client_id and the details for the client. If you wish to have the client be no longer available for further activity without permanently deleting it, use this endpoint to mark a client as inactive by changing the is_active field to false.

HTTP REQUEST

PUT /client/{client_id}

Delete a client

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'

try:
    # Delete a client
    api_instance.delete_client(client_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_client: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

begin
  #Delete a client
  api_instance.delete_client(client_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_client: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
try {
    apiInstance.deleteClient(clientId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteClient");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteClient(clientId, , callback);

Response (204 No Content)

Permanently delete a client registered with your firm. The unique client_id must be provided. To obtain the appropriate client_id, use the GET /client endpoint to view all available client_ids registered with your firm. This deletes the client_id and all the client’s information associated with it. To prevent a client_id from being used for further activity without permanently deleting it, you can use the PUT /client/{client_id} endpoint to mark a client as inactive by changing the is_active field to false.

HTTP REQUEST

DELETE /client/{client_id}

Client Activity

List all client asset sizes

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033/asset_size"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'

try:
    # List all client asset sizes
    api_response = api_instance.get_client_asset_sizes(client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_asset_sizes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

begin
  #List all client asset sizes
  result = api_instance.get_client_asset_sizes(client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_asset_sizes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
try {
    ClientAssetSizeResponse result = apiInstance.getClientAssetSizes(clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientAssetSizes");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientAssetSizes(clientId, , opts, callback);

Example Response

[
    {
        "date": "2018-02-03",
        "value": 20000,
        "additions": 0
    },
    {
        "date": "2018-02-04",
        "value": 24500,
        "additions": 500
    }
]

Get a list of asset sizes per date for a client. Asset size records are created at the portfolio level and aggregated to yield the client asset size(s). The unique client_id must be provided. To obtain the appropriate client_id, use the GET /client endpoint to view all available client_ids registered with your firm. The endpoint returns a list of asset sizes by date for the client. Additional parameters available to narrow down what is returned include: a date range, only obtaining the latest record, and sorting by different units of time (e.g. annually, quarterly, monthly, daily), etc.

HTTP REQUEST

GET /client/{client_id}/asset_size

ARGUMENTS

Parameter Type Required Description
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set
sort_type string optional Sort the asset sizes by D Daily, M Monthly, Q Quarterly, Y Yearly. Defaults to D Daily if not set. Must be capital letters
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
date date Date for this asset size record
value double Monetary value of all the client’s accounts on the particular date
additions double Amount added to all of the client’s accounts on the particular date, usually via deposits

List all client holdings

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033/holding"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'

try:
    # List all client holdings
    api_response = api_instance.get_client_holdings(client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_holdings: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

begin
  #List all client holdings
  result = api_instance.get_client_holdings(client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_holdings: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
try {
    ClientHoldingsResponse result = apiInstance.getClientHoldings(clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientHoldings");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientHoldings(clientId, , opts, callback);

Example Response

[
    {
          "date": "2018-02-03",
          "security_id": "73b5dbcd-0a40-4526-8348-368e17c9575d",
          "weight": 10,
          "amount": 2000,
          "shares": 20
    },
    {
          "date": "2018-02-03",
          "security_id": "691c2255-a1a6-451f-b772-cb262725d7e2",
          "weight": 2,
          "amount": 400,
          "shares": 4
    },
    {
          "date": "2018-02-03",
          "security_id": "0283c814-db55-4470-8cd8-8b9ae945182f",
          "weight": 30,
          "amount": 6000,
          "shares": 60
    },
    {
          "date": "2018-02-03",
          "security_id": "0d652520-7e6a-461d-abe8-56b956c08d2e",
          "weight": 30,
          "amount": 6000,
          "shares": 70
    },
    {
          "date": "2018-02-03",
          "security_id": "c090f392-409d-459a-8054-333fe96fb877",
          "weight": 28,
          "amount": 5600,
          "shares": 50
    }
]

Get the information for all the securities that are currently being held by a client registered with your firm. Holding records are created at a portfolio level and aggregated to show the holdings of the client. The unique client_id must be provided. To obtain the appropriate client_id, use the GET /client endpoint to view all available client_ids registered with your firm. The endpoint returns a list of security_ids, the security amount, the security weight and the date of the record for all securities the client holds. Additional parameters available to narrow down what is returned include a date range and only obtaining the latest record.

HTTP REQUEST

GET /client/{client_id}/holding

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set

RESPONSE

Field Type Description
date date Date for the security holding
security_id UUID The id for the security included in the holding record
weight double The weight of the security as a percentage of the client’s total monetary value; ex. 20 representing 20%
amount double Monetary value of the shares in the holding record
shares double Number of shares in the holding record

List all client transactions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client/099961da-7f41-4309-950f-2b51689a0033/transaction"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_id = '099961da-7f41-4309-950f-2b51689a0033'

try:
    # List all client transactions
    api_response = api_instance.get_client_transactions(client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_transactions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_id = '099961da-7f41-4309-950f-2b51689a0033'

begin
  #List all client transactions
  result = api_instance.get_client_transactions(client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_transactions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientId = new UUID("099961da-7f41-4309-950f-2b51689a0033");
try {
    ClientTransactionResponse result = apiInstance.getClientTransactions(clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientTransactions");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientId = "099961da-7f41-4309-950f-2b51689a0033";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientTransactions(clientId, , opts, callback);

Example Response

{
  "content": [
        {
            "id": "efa289b2-3565-42e6-850b-8dad25727e99",
            "date": "2018-01-31",
            "is_read": true,
            "portfolio_id": "8ec467e6-6faa-4916-b380-6af0b21a34cc",
            "model_id": "6dbadddc-41ff-4634-a145-16678b422557",
            "price": 200,
            "quantity": 2,
            "security_id": "691c2255-a1a6-451f-b772-cb262725d7e2",
            "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386",
            "create_date": "2018-02-07T19:29:37.000+0000",
            "update_date": "2018-02-012T09:00:00.000+0000"
        },
        {
            "id": "efa289b2-3565-42e6-850b-8dad25727e24",
            "date": "2018-01-31",
            "is_read": true,
            "portfolio_id": "8ec467e6-6faa-4916-b380-6af0b21a34cc",
            "model_id": "6dbadddc-41ff-4634-a145-16678b422557",
            "price": 1000,
            "quantity": 6,
            "security_id": "0d652520-7e6a-461d-abe8-56b956c08d2e",
            "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386",
            "create_date": "2017-08-02T04:30:25",
            "update_date": "2017-11-18T09:00:00"
        }
      ],
    "total_pages": 1,
    "total_elements": 2,
    "last": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "id",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 2,
    "size": 25,
    "number": 2
}

Get the information for all transactions under a client registered with your firm. Transactions represent buy or sell orders for securities. Transaction records are created at a portfolio level and all transactions for each portfolio below the client’s account(s) are returned to show the client’s transaction activity. The unique client_id must be provided. To obtain the appropriate client_id, use the GET /client endpoint to view all available client_ids registered with your firm. The endpoint returns a list of transaction_ids and details for each transaction. See the Order section for more information. Additional parameters available to narrow down what is returned include a date range.

HTTP REQUEST

GET /client/{client_id}/transaction

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
id UUID The id for the transaction record
date date Date of the transaction record
is_read boolean Indicates if the transaction has been read. Defaults to false which indicates it has not been read
portfolio_id UUID The id of the portfolio that the transaction falls under
model_id UUID Model to which the portfolio that the transaction falls under subscribes
price integer Price for the security included in the transaction at which it was sold or purchased
quantity integer Quantity of shares of the security purchased
security_id UUID The id of the security included in the transaction
transaction_code_id integer The id referring to the transaction codes defined by your firm
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Client Response

When using questionnaires, clients’ answers to the questions are stored as client responses. For example, to customize a firm-defined goal for a client, he or she must provide some information such as his or her time horizon or goal amount. Another example is when profiling a client’s risk tolerance, a specific questionnaire might be used, where the client’s responses help determine the risk profile. Client responses are stored as answer values connected to the question in the questionnaire via an answer_id that represents an answer option to the question. Responses can be stored at a client level or an account level. The answers are often used as variables for calculations relating to a goal such as age, time horizon, risk tolerance, etc.

Field Type Description
id UUID The id of the client response
answer_id UUID The id of the answer provided to link the response to a question
answer_value string Body of the client’s response
client_id UUID The id of the client to whom the response belongs
account_id UUID In the case that the response applies to only one of a client’s accounts and not the client as a whole, the id of the account to which the response belongs
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all client responses

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_response"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all client responses
    api_response = api_instance.get_client_responses()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_responses: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all client responses
  result = api_instance.get_client_responses()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_responses: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetClientResponseResponse result = apiInstance.getClientResponses();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientResponses");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientResponses(opts, callback);

Example Response

{
     "content": [
        {
            "id": "7960419c-c098-4450-8cc5-866b7385230b",
            "create_date": "2018-02-07T19:29:37.000+0000",
            "update_date": "2018-02-12T09:00:00.000+0000",
            "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
            "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
            "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
            "answer_value" : "10 Years",
      "metadata": {}
        }
     ],
    "total_elements": 1,
    "last": true,
    "total_pages": 1,
    "sort": [
        {
            "direction": "ASC",
            "property": "id",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": true,
            "descending": false
        }
    ],
    "number_of_elements": 1,
    "first": true,
    "size": 25,
    "number": 0
}

Get all the client responses for questions as part of a questionnaire defined by your firm. The option to provide a unique client_id or account_id is available to filter responses from a specific client, or responses from a specific account. To obtain the appropriate client_id, use the GET /client endpoint to view all clients defined for your firm. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm.

HTTP REQUEST

GET /client_response

Create a client response

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d '{
              "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
              "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
              "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
              "answer_value" : "10 Years"
        }' "https://api.hydrogenplatform.com/nucleus/v1/client_response"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.ClientResponsePayload(client_id="5736e6f7-5e12-448e-830c-c1f2b9317d48",
   account_id="efa289b2-3565-42e6-850b-8dad25727e99",
   answer_id="cf9de92f-1c59-4188-93af-d7d5cefd0644",
   answer_value="10 Years")

try:
    # Create a client response
    api_response = api_instance.post_client_response(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_client_response: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::ClientResponsePayload.new
payload.client_id = "5736e6f7-5e12-448e-830c-c1f2b9317d48"
payload.account_id = "efa289b2-3565-42e6-850b-8dad25727e99"
payload.answer_id = "cf9de92f-1c59-4188-93af-d7d5cefd0644"
payload.answer_value = "10 Years"

begin
  #Create a client response
  result = api_instance.post_client_response(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_client_response: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
ClientResponsePayload payload = new ClientResponsePayload(clientId="5736e6f7-5e12-448e-830c-c1f2b9317d48",
    accountId="efa289b2-3565-42e6-850b-8dad25727e99",
    answerId="cf9de92f-1c59-4188-93af-d7d5cefd0644",
    answerValue="10 Years");
try {
    CreateClientResponseResponse result = apiInstance.postClientResponse(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postClientResponse");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.ClientResponsePayload(clientId="5736e6f7-5e12-448e-830c-c1f2b9317d48",
   accountId="efa289b2-3565-42e6-850b-8dad25727e99",
   answerId="cf9de92f-1c59-4188-93af-d7d5cefd0644",
   answerValue="10 Years");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postClientResponse(payload, callback);

Example Response

{
    "id": "7960419c-c098-4450-8cc5-866b7385230b",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
    "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
    "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
    "answer_value" : "10 Years",
    "metadata": {}
}

Create a new client response for a question as part of a questionnaires. Must provide the answer_id and the answer value. To obtain the appropriate answer_id, use the GET /questionnaire endpoint to view the question_id and answer_id pairs. The create_date will default to the current date. The endpoint returns a client_response_id used to manage the client’s response to the question.

HTTP REQUEST

POST /client_response

ARGUMENTS

Parameter Type Required Description
answer_id UUID required The id of the answer provided to link the response to a question
answer_value string required Body of the client’s response
client_id UUID optional The id of the client to whom the response belongs
account_id UUID optional In the case that the response applies to only one of a client’s accounts and not the client as a whole, the id of the account to which the response belongs
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a client response

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_response/7960419c-c098-4450-8cc5-866b7385230b"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_response_id = '7960419c-c098-4450-8cc5-866b7385230b'

try:
    # Retrieve a client response
    api_response = api_instance.get_client_response(client_response_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_response: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_response_id = '7960419c-c098-4450-8cc5-866b7385230b'

begin
  #Retrieve a client response
  result = api_instance.get_client_response(client_response_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_response: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientResponseId = new UUID("7960419c-c098-4450-8cc5-866b7385230b");
try {
    SpecificClientResponseResponse result = apiInstance.getClientResponse(clientResponseId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientResponse");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientResponseId = "7960419c-c098-4450-8cc5-866b7385230b";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientResponse(clientResponseId, callback);

Example Response

{
    "id": "7960419c-c098-4450-8cc5-866b7385230b",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
    "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
    "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
    "answer_value" : "10 Years",
    "metadata": {}
}

Retrieve the information for a client response for a client. The client_response_id must be provided. To obtain the appropriate client_response_id, use the GET /client_response endpoint to view all client responses firm-wide. The endpoint returns the client_response_id and details for the client response.

HTTP REQUEST

GET /client_response/{client_response_id}

Update a client response

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d '{
            "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
            "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
            "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
            "answer_value" : "10 Years"
    }' "https://api.hydrogenplatform.com/nucleus/v1/client_response/7960419c-c098-4450-8cc5-866b7385230b"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_response_id = '7960419c-c098-4450-8cc5-866b7385230b'
payload = atom_api.ClientResponsePayload(client_id="5736e6f7-5e12-448e-830c-c1f2b9317d48",
   account_id="efa289b2-3565-42e6-850b-8dad25727e99",answer_id="cf9de92f-1c59-4188-93af-d7d5cefd0644",
   answer_value="10 Years")

try:
    # Update a client response
    api_response = api_instance.update_client_response(client_response_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_client_response: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_response_id = '7960419c-c098-4450-8cc5-866b7385230b'

payload = AtomApi::ClientResponsePayload.new
payload.client_id = "5736e6f7-5e12-448e-830c-c1f2b9317d48"
payload.account_id = "efa289b2-3565-42e6-850b-8dad25727e99"
payload.answer_id = "cf9de92f-1c59-4188-93af-d7d5cefd0644"
payload.answer_value = "10 Years"

begin
  #Update a client response
  result = api_instance.update_client_response(client_response_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_client_response: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientResponseId = new UUID("7960419c-c098-4450-8cc5-866b7385230b");
ClientResponsePayload payload = new ClientResponsePayload(clientId="5736e6f7-5e12-448e-830c-c1f2b9317d48",
    accountId="efa289b2-3565-42e6-850b-8dad25727e99",
    answerId="cf9de92f-1c59-4188-93af-d7d5cefd0644",
    answerValue="10 Years");
try {
    SpecificClientResponseResponse result = apiInstance.updateClientResponse(clientResponseId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateClientResponse");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientResponseId = "7960419c-c098-4450-8cc5-866b7385230b";

var payload = new atom_api.ClientResponsePayload(clientId="5736e6f7-5e12-448e-830c-c1f2b9317d48",
   accountId="efa289b2-3565-42e6-850b-8dad25727e99",
   answerId="cf9de92f-1c59-4188-93af-d7d5cefd0644",
   answerValue="10 Years");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateClientResponse(clientResponseIdpayload, callback);

Example Response

{
    "id": "7960419c-c098-4450-8cc5-866b7385230b",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "client_id" : "5736e6f7-5e12-448e-830c-c1f2b9317d48",
    "account_id" : "efa289b2-3565-42e6-850b-8dad25727e99",
    "answer_id" : "cf9de92f-1c59-4188-93af-d7d5cefd0644",
    "answer_value" : "10 Years",
    "metadata": {}
}

Update a client response for a client. The client_response_id must be provided. To obtain the appropriate client_response_id, use the GET /client_response endpoint to view all client responses firm-wide and their current information. The details to be updated must also be provided. The endpoint returns the client_response_id and all the details for the client response.

HTTP REQUEST

PUT /client_response/{client_response_id}

Delete a client response

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_response/7960419c-c098-4450-8cc5-866b7385230b0"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_response_id = '7960419c-c098-4450-8cc5-866b7385230b0'

try:
    # Delete a client response
    api_instance.delete_client_response(client_response_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_client_response: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_response_id = '7960419c-c098-4450-8cc5-866b7385230b0'

begin
  #Delete a client response
  api_instance.delete_client_response(client_response_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_client_response: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientResponseId = new UUID("7960419c-c098-4450-8cc5-866b7385230b0");
try {
    apiInstance.deleteClientResponse(clientResponseId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteClientResponse");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientResponseId = "7960419c-c098-4450-8cc5-866b7385230b0";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteClientResponse(clientResponseId, callback);

Response (204 No Content)

Permanently delete a client response for a client. The client_response_id must be provided. To obtain the appropriate client_response_id, use the GET /client_response endpoint to view all client responses firm-wide. This deletes the client_response_id and the client response record.

HTTP REQUEST

DELETE /client_response/{client_response_id}

Client Hydro

The Client-Hydro entity represents the relationship between a client in the platform and the client’s Hydro ID. This entity is also used to store attributes relating to integrations with Hydro API capabilities.

Field Type Description
id UUID The id of the client-hydro relationship
client_id UUID The id of the client to whom the Hydro ID belongs
hydro_id string The Hydro ID for the client. Also found under the client object
is_hydro_id_verified boolean Indicator if the client has verified ownership of the Hydro ID provided. Defaults to false which means ownership has not been verified
is_client_raindrop_linked boolean Indicator for whether or not the client has successfully linked their Hydro ID to your Client-side Raindrop application. Defaults to false which indicates it has not been linked
is_client_raindrop_enabled boolean Indicator for whether or not the client has chosen to enable the Hydro Client-side Raindrop service on your application. Defaults to false which indicates the service is not enabled
metadata map Custom information associated with the client-hydro relationship in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all client-hydro relationship

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_hydro"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all client-hydro relationships
    api_response = api_instance.get_client_hydros()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_hydros: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all client-hydro relationships
  result = api_instance.get_client_hydros()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_hydros: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetClientHydroResponse result = apiInstance.getClientHydros();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientHydros");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientHydros(opts, callback);

Example Response

{
    "content": [
        {
            "id": "d787cf19-d11c-49f2-abf3-f5fec1b101d4",
            "create_date": "2018-07-30T00:00:00.000+0000",
            "update_date": "2018-07-31T00:00:00.000+0000",
            "client_id": "1f9a4b00-0a06-4cfa-8774-3d5485206bda",
            "hydro_id": "10lm4nz",
            "is_hydro_id_verified": true,
            "is_client_raindrop_linked": true,
            "is_client_raindrop_enabled": true,
            "metadata": {}
        },
        {
            "id": "08628a95-5b2c-4070-86eb-fdae95f58cbd",
            "create_date": "2018-11-09T00:00:00.000+0000",
            "update_date": "2018-11-10T00:00:00.000+0000",
            "client_id": "b475b55c-e1a3-4348-87fe-29db0f0a843e",
            "hydro_id": "10lm4nz",
            "is_hydro_id_verified": true,
            "is_client_raindrop_linked": false,
            "is_client_raindrop_enabled": false,
            "metadata": {}
        },
        {
            "id": "90b7b9cd-63d1-470d-b103-d46cfc1db711",
            "create_date": "2018-11-30T00:00:00.000+0000",
            "update_date": "2018-12-01T00:00:00.000+0000",
            "client_id": "643ed0d0-e043-41e9-aa9e-19611e53cdd4",
            "hydro_id": "10lm4nz",
            "is_hydro_id_verified": true,
            "is_client_raindrop_linked": false,
            "is_client_raindrop_enabled": true,
            "metadata": {}
        }

    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get information for all client-hydro relationships for all clients defined for your firm. You can filter using a unique client_id to view the client-hydro relationships for a client and the client’s Hydro ID information. To identify the appropriate client_id, use the GET /client endpoint to see all clients defined for your firm. Note that the metadata information is stored as a nested object within the client-hydro object.

HTTP REQUEST

GET /client_hydro

Create a client-hydro relationship

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
        "client_id": "04266c1d-62e8-457e-b972-4ef2cfa78399",
        "hydro_id": "10lm4nz",
        "is_hydro_id_verified": true,
        "is_client_raindrop_linked": true,
        "is_client_raindrop_enabled": true
    }' "https://api.hydrogenplatform.com/nucleus/v1/client_hydro"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.ClientHydroPayload(client_id="04266c1d-62e8-457e-b972-4ef2cfa78399",
    hydro_id="10lm4nz",
    is_hydro_id_verified=True,
    is_client_raindrop_linked=True,
    is_client_raindrop_enabled=True)

try:
    # Create a client-hydro relationship
    api_response = api_instance.post_client_hydro(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_client_hydro: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::ClientHydroPayload.new
payload.client_id = "04266c1d-62e8-457e-b972-4ef2cfa78399"
payload.hydro_id = "10lm4nz"
payload.is_hydro_id_verified = true
payload.is_client_raindrop_linked = true
payload.is_client_raindrop_enabled = true

begin
  #Create a client-hydro relationship
  result = api_instance.post_client_hydro(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_client_hydro: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
ClientHydroPayload payload = new ClientHydroPayload(clientId="04266c1d-62e8-457e-b972-4ef2cfa78399",
    hydroId="10lm4nz",
    isHydroIdVerified=true,
    isClientRaindropLinked=true,
    isClientRaindropEnabled=true);
try {
    CreateClientHydroResponse result = apiInstance.postClientHydro(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postClientHydro");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.ClientHydroPayload(clientId="04266c1d-62e8-457e-b972-4ef2cfa78399",
    hydroId="10lm4nz",
    isHydroIdVerified=true,
    isClientRaindropLinked=true,
    isClientRaindropEnabled=true);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postClientHydro(payload, callback);

Example Response

{
    "id": "d787cf19-d11c-49f2-abf3-f5fec1b101d4",
    "create_date": "2018-07-30T00:00:00.000+0000",
    "client_id": "04266c1d-62e8-457e-b972-4ef2cfa78399",
    "hydro_id": "10lm4nz",
    "is_hydro_id_verified": true,
    "is_client_raindrop_linked": true,
    "is_client_raindrop_enabled": true,
    "metadata": {}
}

Create an client-hydro relationship under a client. The client_id must be provided. To identify the appropriate client_id, use the GET /client endpoint to see all clients for your firm. The endpoint returns an client_hydro_id that can then be used to manage the client-hydro relationship.

HTTP REQUEST

POST /client_hydro

ARGUMENTS

Parameter Type Required Description
client_id UUID required The id of the client to whom the Hydro ID belongs
hydro_id string required The hydro ID for the client. Also found under the client object
is_hydro_id_verified boolean optional Indicator if the client has verified ownership of the Hydro ID provided. Defaults to false which means ownership has not been verified
is_client_raindrop_linked boolean optional Indicator for whether or not the client has successfully linked their Hydro ID to your Client-side Raindrop application. Defaults to false which indicates it has not been linked
is_client_raindrop_enabled boolean optional Indicator for whether or not the client has chosen to enable the Hydro Client-side Raindrop service on your application. Defaults to false which indicates the service is not enabled
metadata map optional Custom information associated with the client-hydro relationship in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a client-hydro relationship

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_hydro/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

try:
    # Retrieve a client-hydro relationship
    api_response = api_instance.get_client_hydro(client_hydro_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_client_hydro: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

begin
  #Retrieve a client-hydro relationship
  result = api_instance.get_client_hydro(client_hydro_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_client_hydro: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientHydroId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
try {
    SpecificClientHydroResponse result = apiInstance.getClientHydro(clientHydroId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getClientHydro");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientHydroId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getClientHydro(clientHydroId, callback);

Example Response

{
    "id": "d787cf19-d11c-49f2-abf3-f5fec1b101d4",
    "create_date": "2018-07-30T00:00:00.000+0000",
    "client_id": "1f9a4b00-0a06-4cfa-8774-3d5485206bda",
    "hydro_id": "10lm4nz",
    "is_hydro_id_verified": true,
    "is_client_raindrop_linked": true,
    "is_client_raindrop_enabled": true,
    "metadata": {}
}

Retrieve the information for a specific client-hydro relationship. The unique client_hydro_id must be provided. The endpoint returns the client_hydro_id and details for the client-hydro relationship specified. Note that the metadata information is stored as a nested object within the client-hydro object.

HTTP REQUEST

GET /client_hydro/{client_hydro_id}

Update a client-hydro relationship

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{
        "client_id": "1f9a4b00-0a06-4cfa-8774-3d5485206bda",
        "hydro_id": "10lm4nz",
        "is_hydro_id_verified": true,
        "is_client_raindrop_linked": false,
        "is_client_raindrop_enabled": false
    }' "https://api.hydrogenplatform.com/nucleus/v1/client_hydro/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'
payload = atom_api.ClientHydroPayload(client_id="1f9a4b00-0a06-4cfa-8774-3d5485206bda",
      hydro_id="10lm4nz",
      is_hydro_id_verified=True,
      is_client_raindrop_linked=False,
      is_client_raindrop_enabled=False)

try:
    # Update a client-hydro relationship
    api_response = api_instance.update_client_hydro(client_hydro_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_client_hydro: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

payload = AtomApi::ClientHydroPayload.new
payload.client_id = "1f9a4b00-0a06-4cfa-8774-3d5485206bda"
payload.hydro_id = "10lm4nz"
payload.is_hydro_id_verified = true
payload.is_client_raindrop_linked = false
payload.is_client_raindrop_enabled = false

begin
  #Update a client-hydro relationship
  result = api_instance.update_client_hydro(client_hydro_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_client_hydro: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientHydroId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
ClientHydroPayload payload = new ClientHydroPayload(clientId="1f9a4b00-0a06-4cfa-8774-3d5485206bda",
    hydroId="10lm4nz",
    isHydroIdVerified=true,
    isClientRaindropLinked=false,
    isClientRaindropEnabled=false);
try {
    SpecificClientHydroResponse result = apiInstance.updateClientHydro(clientHydroId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateClientHydro");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi(clientId="1f9a4b00-0a06-4cfa-8774-3d5485206bda",
  hydroId="10lm4nz",
  isHydroIdVerified=true,
  isClientRaindropLinked=false,
  isClientRaindropEnabled=false);

var clientHydroId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var payload = new atom_api.ClientHydroPayload();

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateClientHydro(clientHydroIdpayload, callback);

Example Response

{
    "id": "d787cf19-d11c-49f2-abf3-f5fec1b101d4",
    "create_date": "2018-07-30T00:00:00.000+0000",
    "update_date": "2019-01-30T00:00:00.000+0000",
    "client_id": "1f9a4b00-0a06-4cfa-8774-3d5485206bda",
    "hydro_id": "10lm4nz",
    "is_hydro_id_verified": true,
    "is_client_raindrop_linked": false,
    "is_client_raindrop_enabled": false,
    "metadata": {}
}

Update the information for a client-hydro relationship. The unique client_hydro_id must be provided. To obtain the appropriate client_hydro_id, use the GET /client_hydro endpoint to view all client-hydro relationships defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the client_hydro_id and the details for the client-hydro relationship.

HTTP REQUEST

PUT /client_hydro/{client_hydro_id}

Delete a client-hydro relationship

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/client_hydro/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

try:
    # Delete a client-hydro relationship
    api_instance.delete_client_hydro(client_hydro_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_client_hydro: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

client_hydro_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

begin
  #Delete a client-hydro relationship
  api_instance.delete_client_hydro(client_hydro_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_client_hydro: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID clientHydroId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
try {
    apiInstance.deleteClientHydro(clientHydroId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteClientHydro");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var clientHydroId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteClientHydro(clientHydroId, callback);

Response (204 No Content)

Permanently delete a client-hydro relationship for a Hydro ID and a client. The unique client_hydro_id must be provided. To obtain the appropriate client_hydro_id, use the GET /client_hydro endpoint to view all client-hydro relationships defined for your firm. This deletes the client_hydro_id and all client-hydro relationship record information.

HTTP REQUEST

DELETE /client_hydro/{client_hydro_id}

Decision Tree

Decision trees are designed to guide your users in determining the best course of action for them based on their objectives. For example, a decision tree can be used to determine the most suitable allocation for a client’s investment portfolio according to a goal, time horizon, risk profile etc. Decision trees can also be used to guide the order of questionnaire questions; specifically, if the question order is meant to be dynamic and may change based on a client’s responses, then a decision tree needs to be used. Decision trees consist of a series of nodes, which generally represent questionnaire question and answer combinations. These nodes are linked together via node relationships. Each decision tree has an initial node. This node is mapped to a child node via a node relationship. The child node is then mapped to a subsequent child node via another node relationship, and so on. Certain nodes will be end nodes, or “leaves”, and those can be mapped to allocation(s) or models if applicable. These final node relationship in a branch of a decision tree is identified with an is_leaf flag, where true indicates that the child_node in the node relationship is the end node.

Tree Management

Field Type Description
id UUID The id of the decision tree
name string Name of the decision tree
category string A category for the decision tree such as “Onboarding” or “Risk Profile”
subcategory string A subcategory for the decision tree such as “Income-related”
description string Description for the decision tree such as “Tree to allocate clients to taxable portfolios”
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all decision trees

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/decision_tree"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all decision trees
    api_response = api_instance.get_decision_trees()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_decision_trees: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all decision trees
  result = api_instance.get_decision_trees()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_decision_trees: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetDecisionTreeResponse result = apiInstance.getDecisionTrees();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getDecisionTrees");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getDecisionTrees(opts, callback);

Example Response

{
    "content": [
        {
            "id": "28021071-bece-400b-a0f6-23fb13adfcd3",
            "create_date": "2018-03-26T19:49:47.000+0000",
            "update_date": "2018-03-26T19:49:47.000+0000",
            "name": "Retirement Account Tree",
            "category": "Retirement Profile",
            "subcategory": "Income-related",
            "description": "Decision tree which allocates people looking to open a retirement account",
            "metadata": {}
        },
        {
            "id": "0a5b1bf9-1e22-4eb2-b366-abacefc7a23b",
            "create_date": "2018-03-23T16:31:24.000+0000",
            "update_date": "2018-03-23T16:31:24.000+0000",
            "name": "Retirement Account Tree",
            "category": "Retirement Profile",
            "subcategory": "Income-related",
            "description": "Decision tree which allocates people looking to open a retirement account",
            "metadata": {}
        },
        {
            "id": "0e62f776-b9e9-43cb-8e37-00d8b5133eee",
            "create_date": "2018-03-23T16:24:07.000+0000",
            "update_date": "2018-03-23T16:24:07.000+0000",
            "name": "Retirement Account Tree",
            "category": "Retirement Profile",
            "subcategory": "Income-related",
            "description": "Decision tree which allocates people looking to open a retirement account",
            "metadata": {}
        }
    ],
    "total_pages": 1,
    "total_elements": 3,
    "last": true,
    "first": true,
    "sort": [
        {
          "direction": "DESC",
          "property": "id",
          "ignore_case": false,
          "null_handling": "NATIVE",
          "ascending": false,
          "descending": true
        }
    ],
    "number_of_elements": 1,
    "size": 25,
    "number": 0
}

Get the information for all decision trees defined for your firm. The endpoint returns the id and the description details for each decision tree.

HTTP REQUEST

GET /decision_tree

Create a decision tree

Example Request

curl -X POST -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "name": "Retirement Account Tree",
              "category": "Retirement Profile",
              "subcategory": "Income-related",
              "description": "Decision tree which allocates people looking to open a retirement account"
          }' "https://api.hydrogenplatform.com/nucleus/v1/decision_tree"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.DecisionTreePayload(name="Retirement Account Tree",
    description="Decision tree which allocates people looking to open a retirement account")

try:
    # Create a decision tree
    api_response = api_instance.post_decision_tree(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_decision_tree: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::DecisionTreePayload.new
payload.name = "Retirement Account Tree"
payload.description = "Decision tree which allocates people looking to open a retirement account"

begin
  #Create a decision tree
  result = api_instance.post_decision_tree(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_decision_tree: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
DecisionTreePayload payload = new DecisionTreePayload(name="Retirement Account Tree",
    description="Decision tree which allocates people looking to open a retirement account");
try {
    CreateDecisionTreeResponse result = apiInstance.postDecisionTree(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postDecisionTree");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.DecisionTreePayload(name="Retirement Account Tree",
  description="Decision tree which allocates people looking to open a retirement account");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postDecisionTree(payload, callback);

Example Response

{
    "id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "create_date": "2018-03-26T19:49:47.000+0000",
    "name": "Retirement Account Tree",
    "category": "Retirement Profile",
    "subcategory": "Income-related",
    "description": "Decision tree which allocates people looking to open a retirement account",
    "metadata": {}
}

Create a new decision tree for your firm. The create_date will default to the current date. The endpoint returns a decision_tree_id used to manage the decision tree and assign it to other entities.

HTTP REQUEST

POST /decision_tree

ARGUMENTS

Parameter Type Required Description
name string required Name of the decision tree
category string optional A category for the decision tree such as “Onboarding” or “Risk Profile”
subcategory string optional A subcategory for the decision tree such as “Income-related”
description string optional Description for the decision tree such as “Tree to allocate clients to taxable portfolios”
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a decision tree

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      "https://api.hydrogenplatform.com/nucleus/v1/decision_tree/28021071-bece-400b-a0f6-23fb13adfcd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'

try:
    # Retrieve a decision tree
    api_response = api_instance.get_decision_tree(decision_tree_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_decision_tree: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'

begin
  #Retrieve a decision tree
  result = api_instance.get_decision_tree(decision_tree_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_decision_tree: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID decisionTreeId = new UUID("28021071-bece-400b-a0f6-23fb13adfcd3");
try {
    SpecificDecisionTreeResponse result = apiInstance.getDecisionTree(decisionTreeId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getDecisionTree");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var decisionTreeId = "28021071-bece-400b-a0f6-23fb13adfcd3";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getDecisionTree(decisionTreeId, callback);

Example Response

{
    "id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "create_date": "2018-03-26T19:49:47.000+0000",
    "update_date": "2018-03-26T19:49:47.000+0000",
    "name": "Retirement Account Tree",
    "category": "Retirement Profile",
    "subcategory": "Income-related",
    "description": "Decision tree which allocates people looking to open a retirement account",
    "metadata": {}
}

Retrieve the information for a decision tree. The decision_tree_id must be provided. This endpoint returns the decision_tree_id and the details for the decision tree specified.

HTTP REQUEST

GET /decision_tree/{decision_tree_id}

Update a decision tree

Example Request

curl -X PUT -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "name": "Retirement Account Tree",
              "category": "Retirement Profile",
              "subcategory": "Income-related",
              "description": "Decision tree which allocates people looking to open a retirement account"
          }' "https://api.hydrogenplatform.com/nucleus/v1/decision_tree/28021071-bece-400b-a0f6-23fb13adfcd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'
payload = atom_api.DecisionTreePayload(name="Retirement Account Tree",
   description="Decision tree which allocates people looking to open a retirement account")

try:
    # Update a decision tree
    api_response = api_instance.update_decision_tree(decision_tree_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_decision_tree: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'

payload = AtomApi::DecisionTreePayload.new
payload.name = "Retirement Account Tree"
payload.description = "Decision tree which allocates people looking to open a retirement account"

begin
  #Update a decision tree
  result = api_instance.update_decision_tree(decision_tree_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_decision_tree: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID decisionTreeId = new UUID("28021071-bece-400b-a0f6-23fb13adfcd3");
DecisionTreePayload payload = new DecisionTreePayload(name="Retirement Account Tree",
    description="Decision tree which allocates people looking to open a retirement account");
try {
    SpecificDecisionTreeResponse result = apiInstance.updateDecisionTree(decisionTreeId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateDecisionTree");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var decisionTreeId = "28021071-bece-400b-a0f6-23fb13adfcd3";

var payload = new atom_api.DecisionTreePayload(name="Retirement Account Tree",
    description="Decision tree which allocates people looking to open a retirement account");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateDecisionTree(decisionTreeIdpayload, callback);

Example Response

{
    "id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "create_date": "2018-03-26T19:49:47.000+0000",
    "update_date": "2018-03-26T19:49:47.000+0000",
    "name": "Retirement Account Tree",
    "category": "Retirement Profile",
    "subcategory": "Income-related",
    "description": "Decision tree which allocates people looking to open a retirement account",
    "metadata": {}
}

Updated the information for a decision tree. The decision_tree_id must be provided. To obtain the appropriate decision_tree_id, use the GET /decision_tree endpoint to view all decision trees defined for your firm and their current information. The details to be updated must also be provided. This endpoint returns the decision_tree_id and the details for the decision tree.

HTTP REQUEST

PUT /decision_tree/{decision_tree_id}

Delete a decision tree

Example Request

curl -X DELETE -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/decision_tree/28021071-bece-400b-a0f6-23fb13adfcd3"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'

try:
    # Delete a decision tree
    api_instance.delete_decision_tree(decision_tree_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_decision_tree: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

decision_tree_id = '28021071-bece-400b-a0f6-23fb13adfcd3'

begin
  #Delete a decision tree
  api_instance.delete_decision_tree(decision_tree_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_decision_tree: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID decisionTreeId = new UUID("28021071-bece-400b-a0f6-23fb13adfcd3");
try {
    apiInstance.deleteDecisionTree(decisionTreeId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteDecisionTree");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var decisionTreeId = "28021071-bece-400b-a0f6-23fb13adfcd3";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteDecisionTree(decisionTreeId, callback);

Response (204 No Content)

Permanently delete a decision tree. The decision_tree_id must be provided. To obtain the appropriate decision_tree_id, use the GET /decision_tree endpoint to view all decision trees defined for your firm. This deletes the decision_tree_id and the details for the decision tree.

HTTP REQUEST

DELETE /decision_tree/{decision_tree_id}

Nodes

Nodes correspond to question and answer combinations along a decision tree that a client must answer, usually as part of a questionnaire. Nodes are linked together in parent-child relationships to create a branch of a decision tree. The first node of a branch is used to map to the first question of a questionnaire. When creating a decision tree, you should create a node corresponding to each question in the questionnaire and the possible answer combinations for the questions before the current question. The last node along the branch is the end node and maps to one or more allocations or models.

Field Type Description
id UUID The id of the node
name string Name of the node
is_first boolean Indicates if this is the first node of the decision tree. Defaults to false meaning it is not the first node
question_id UUID The id of the question that corresponds to this node
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all nodes

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/node"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all nodes
    api_response = api_instance.get_nodes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_nodes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all nodes
  result = api_instance.get_nodes()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_nodes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetNodeResponse result = apiInstance.getNodes();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getNodes");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getNodes(opts, callback);

Example Response

{
    "content": [
        {
            "id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
            "create_date": "2018-03-26T19:50:51.000+0000",
            "update_date": "2018-03-26T19:50:51.000+0000",
            "name": "What is your age?",
            "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
            "is_first": false,
            "metadata": {}
        },
        {
            "id": "0faa837e-370d-4721-8cbc-e2e167d973d9",
            "create_date": "2018-03-26T19:50:51.000+0000",
            "update_date": "2018-03-26T19:50:51.000+0000",
            "name": "What is your annual income in dollars?",
            "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
            "is_first": false,
            "metadata": {}
        },
        {
            "id": "1154c13c-0f5b-4c39-80ac-196633169a2e",
            "create_date": "2018-03-26T19:50:51.000+0000",
            "update_date": "2018-03-26T19:50:51.000+0000",
            "name": "What is your risk tolerance?",
            "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
            "is_first": false,
            "metadata": {}
        }
    ],
    "total_pages": 1,
    "total_elements": 3,
    "last": false,
    "number_of_elements": 25,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "size": 25,
    "number": 0
}

List all nodes that are defined for your firm. The endpoint returns the node_id and the details for the node.

HTTP REQUEST

GET /node

Create a node

Example Request

curl -X POST -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "name": "What is your annual income in dollars?",
              "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
              "is_first": false
          }' "https://api.hydrogenplatform.com/nucleus/v1/node"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.NodePayload(name="What is your annual income in dollars?",
     question_id="286ddd93-4fed-4e01-b26b-838813212c34",
     is_first=False)

try:
    # Create a node
    api_response = api_instance.post_node(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_node: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::NodePayload.new
payload.name = "What is your annual income in dollars?"
payload.question_id = "286ddd93-4fed-4e01-b26b-838813212c34"
payload.is_first = false

begin
  #Create a node
  result = api_instance.post_node(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_node: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
NodePayload payload = new NodePayload(name="What is your annual income in dollars?",
    questionId="286ddd93-4fed-4e01-b26b-838813212c34",
    isFirst=false);
try {
    CreateNodeResponse result = apiInstance.postNode(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postNode");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.NodePayload(name="What is your annual income in dollars?",
    questionId="286ddd93-4fed-4e01-b26b-838813212c34",
    isFirst=false);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postNode(payload, callback);

Example Response

{
    "id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "create_date": "2018-03-26T19:50:51.000+0000",
    "name": "What is your annual income in dollars?",
    "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
    "is_first": false,
    "metadata": {}
}

Create a new node for your firm that can be used in a decision tree and mapped to other nodes. The question_id in the node must be provided. To obtain the appropriate question_id, use the GET /questionnaire/{questionnaire_id} endpoint to view all the question_ids for a questionnaire. The create_date will default to the current date. The endpoint returns a node_id used to map the node to a decision tree and to other nodes.

HTTP REQUEST

POST /node

ARGUMENTS

Parameter Type Required Description
name string required Name of the node
question_id UUID required The id of the question that corresponds to this node
is_first boolean optional Indicates if this is the first node of the decision tree. Defaults to false meaning it is not the first node
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a node

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      "https://api.hydrogenplatform.com/nucleus/v1/node/05b9f2e6-aabc-44b5-8e02-f1ab216ebd62"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'

try:
    # Retrieve a node
    api_response = api_instance.get_node(node_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_node: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'

begin
  #Retrieve a node
  result = api_instance.get_node(node_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_node: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeId = new UUID("05b9f2e6-aabc-44b5-8e02-f1ab216ebd62");
try {
    SpecificNodeResponse result = apiInstance.getNode(nodeId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getNode");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeId = "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getNode(nodeId, callback);

Example Response

{
    "id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "create_date": "2018-03-26T19:50:51.000+0000",
    "update_date": "2018-03-26T19:50:51.000+0000",
    "name": "What is your annual income in dollars?",
    "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
    "is_first": false,
    "metadata": {}
}

Retrieve the information for a node. The node_id must be provided. The endpoint returns the node_id and the details for the node specified.

HTTP REQUEST

GET /node/{node_id}

Update a node

Example Request

curl -X PUT -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "name": "What is your annual income in dollars?",
              "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
              "is_first": false
          }' "https://api.hydrogenplatform.com/nucleus/v1/node/05b9f2e6-aabc-44b5-8e02-f1ab216ebd62"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'
payload = atom_api.NodePayload(name="What is your annual income in dollars?",
   question_id="286ddd93-4fed-4e01-b26b-838813212c34",
   is_first=False)

try:
    # Update a node
    api_response = api_instance.update_node(node_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_node: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'

payload = AtomApi::NodePayload.new
payload.name = "What is your annual income in dollars?"
payload.question_id = "286ddd93-4fed-4e01-b26b-838813212c34"
payload.is_first = false

begin
  #Update a node
  result = api_instance.update_node(node_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_node: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeId = new UUID("05b9f2e6-aabc-44b5-8e02-f1ab216ebd62");
NodePayload payload = new NodePayload(name="What is your annual income in dollars?",
    questionI="286ddd93-4fed-4e01-b26b-838813212c34",
    isFirst=false);
try {
    SpecificNodeResponse result = apiInstance.updateNode(nodeId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateNode");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeId = "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62";

var payload = new atom_api.NodePayload(name="What is your annual income in dollars?",
    questionI="286ddd93-4fed-4e01-b26b-838813212c34",
    isFirst=false);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateNode(nodeIdpayload, callback);

Example Response

{
    "id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "create_date": "2018-03-26T19:50:51.000+0000",
    "update_date": "2018-03-26T19:50:51.000+0000",
    "name": "What is your annual income in dollars?",
    "question_id": "286ddd93-4fed-4e01-b26b-838813212c34",
    "is_first": false,
    "metadata": {}
}

Updated the information for a node. The node_id must be provided. To obtain the appropriate node_id, use the GET /node endpoint to view all the nodes defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the node_id and the details for the node.

HTTP REQUEST

PUT /node/{node_id}

Delete a node

Example Request

curl -X DELETE -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
    "https://api.hydrogenplatform.com/nucleus/v1/node/05b9f2e6-aabc-44b5-8e02-f1ab216ebd62"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'

try:
    # Delete a node
    api_instance.delete_node(node_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_node: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_id = '05b9f2e6-aabc-44b5-8e02-f1ab216ebd62'

begin
  #Delete a node
  api_instance.delete_node(node_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_node: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeId = new UUID("05b9f2e6-aabc-44b5-8e02-f1ab216ebd62");
try {
    apiInstance.deleteNode(nodeId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteNode");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeId = "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteNode(nodeId, callback);

Response (204 No Content)

Permanently delete a node. The node_id must be provided. To obtain the appropriate node_id, use the GET /node endpoint to view all the nodes defined for your firm. This deletes the node_id and the details for the node.

HTTP REQUEST

DELETE /node/{node_id}

Node Relationships

Node relationships indicate the order in which nodes should follow each other along a decision tree branch. Each node relationship corresponds to the possible path that can be taken after a question based on the response provided by a client. The answer_id in the node relationship is used to identify the client response provided for that answer_id. You must create a node relationship for every required node-to-node flow, eventually leading to the last node of the decision tree, which maps to the corresponding allocation or model.

Field Type Description
id UUID The id of the node relationship
answer_id UUID The id of the answer to a question_id that corresponds to the node relationship
value string Value of the answer
decision_tree_id UUID The id of the decision tree to which the node relationship belongs
node_parent_id UUID The id for the parent node
node_child_id UUID The id for the child node
is_leaf boolean Indicates if the node relationship represents the last point in the decision tree branch. true indicates that the next node is the last node, and that it maps to an allocation or model
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all node relationships

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      "https://api.hydrogenplatform.com/nucleus/v1/node_relationship"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all node relationships
    api_response = api_instance.get_node_relationships()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_node_relationships: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all node relationships
  result = api_instance.get_node_relationships()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_node_relationships: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetNodeRelationshipResponse result = apiInstance.getNodeRelationships();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getNodeRelationships");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getNodeRelationships(opts, callback);

Example Response

{
  "content": [
      {
          "id": "8397d8fd-e80d-48ea-bf79-81f32b12606e",
          "create_date": "2018-03-26T19:54:31.000+0000",
          "update_date": "2018-03-26T19:54:31.000+0000",
          "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
          "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
          "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
          "value": "high",
          "is_leaf": false,
          "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
          "metadata": {}
      },
      {
          "id": "c7114848-d17f-420e-b73b-53a5b8fca9d9",
          "create_date": "2018-03-26T19:54:31.000+0000",
          "update_date": "2018-03-26T19:54:31.000+0000",
          "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
          "node_child_id": "df9b27e4-f619-4deb-b207-5635dbb15bb4",
          "answer_id": "0217b35e-36fe-4796-8e7f-61e93e9e6ef5",
          "value": "medium",
          "is_leaf": false,
          "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
          "metadata": {}
      },
      {
          "id": "84f29454-498b-4785-91ac-1f9af0c686c6",
          "create_date": "2018-03-26T19:54:28.000+0000",
          "update_date": "2018-03-26T19:54:28.000+0000",
          "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
          "node_child_id": "a787a485-555b-4463-af83-d3643a767d96",
          "answer_id": "0217b35e-36fe-4796-8e7f-61e93e9e6ef5",
          "value": "low",
          "is_leaf": true,
          "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
          "metadata": {}
      }
  ],
  "total_pages": 1,
  "last": true,
  "total_elements": 3,
  "first": true,
  "sort": [
    {
      "direction": "DESC",
      "property": "id",
      "ignore_case": false,
      "null_handling": "NATIVE",
      "ascending": false,
      "descending": true
    }
  ],
  "number_of_elements": 1,
  "size": 25,
  "number": 0
}

Get the information for all the node relationships defined for your firm. The endpoint returns a list of UUIDs and the details for all node relationships.

HTTP REQUEST

GET /node_relationship

Create a node relationship

Example Request

curl -X POST -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
              "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
              "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
              "value": "high",
              "is_leaf": false,
              "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3"
          }' "https://api.hydrogenplatform.com/nucleus/v1/node_relationship"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.NodeRelationshipPayload(node_parent_id="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
     node_child_id="d5011ba6-50c6-427b-a29c-b7802a2c8660",
     answer_id="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
     value="high",
     is_leaf=False,
     decision_tree_id="28021071-bece-400b-a0f6-23fb13adfcd3")

try:
    # Create a node relationship
    api_response = api_instance.post_node_relationship(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_node_relationship: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::NodeRelationshipPayload.new
payload.node_parent_id = "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62"
payload.node_child_id = "d5011ba6-50c6-427b-a29c-b7802a2c8660"
payload.answer_id = "556cedaa-37ba-4dc7-ad03-0990b9252e1d"
payload.value = "high"
payload.is_leaf = false
payload.decision_tree_id = "28021071-bece-400b-a0f6-23fb13adfcd3"

begin
  #Create a node relationship
  result = api_instance.post_node_relationship(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_node_relationship: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
NodeRelationshipPayload payload = new NodeRelationshipPayload(nodeParentId="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    nodeChildId="d5011ba6-50c6-427b-a29c-b7802a2c8660",
    answerId="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
    value="high",
    isLeaf=false,
    decisionTreeId="28021071-bece-400b-a0f6-23fb13adfcd3");
try {
    CreateNodeRelationshipResponse result = apiInstance.postNodeRelationship(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postNodeRelationship");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.NodeRelationshipPayload(nodeParentId="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
   nodeChildId="d5011ba6-50c6-427b-a29c-b7802a2c8660",
   answerId="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
   value="high",
   isLeaf=false,
   decisionTreeId="28021071-bece-400b-a0f6-23fb13adfcd3");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postNodeRelationship(payload, callback);

Example Response

{
    "id": "8397d8fd-e80d-48ea-bf79-81f32b12606e",
    "create_date": "2018-03-26T19:54:31.000+0000",
    "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
    "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
    "value": "high",
    "is_leaf": false,
    "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "metadata": {}
}

Create a new node relationship for your firm. The answer_id, the node_id of the parent node, the node_id of the child node and the decision_tree_id must be provided. To obtain the appropriate answer_id, use the GET /questionnaire/{questionnaire_id} endpoint to view all the answer_ids for a questionnaire. To obtain the appropriate node_ids, use the GET /node endpoint to view all the nodes defined for your firm. To obtain the appropriate decision_tree_id, use the GET /decision_tree endpoint to view all the decision trees defined for your firm. The endpoint returns a node_relationship_id used to store the mapping between two nodes, as well as the last node to an allocation or model (if applicable).

HTTP REQUEST

POST /node_relationship

ARGUMENTS

Parameter Type Required Description
answer_id UUID required The id of the answer to a question_id that corresponds to the node relationship
value string required Value of the answer
decision_tree_id UUID required The id of the decision tree to which the node relationship belongs
node_parent_id UUID required The id for the parent node.
node_child_id UUID optional The id for the child node.
is_leaf boolean optional Indicator if the node relationship represents the last point in the decision tree branch. true indicates it is the last point and that is maps to an allocation or model
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a node relationship

Example Request

curl -X GET -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      "https://api.hydrogenplatform.com/nucleus/v1/node_relationship/8397d8fd-e80d-48ea-bf79-81f32b12606e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'

try:
    # Retrieve a node relationship
    api_response = api_instance.get_node_relationship(node_relationship_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_node_relationship: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'

begin
  #Retrieve a node relationship
  result = api_instance.get_node_relationship(node_relationship_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_node_relationship: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeRelationshipId = new UUID("8397d8fd-e80d-48ea-bf79-81f32b12606e");
try {
    SpecificNodeRelationshipResponse result = apiInstance.getNodeRelationship(nodeRelationshipId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getNodeRelationship");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeRelationshipId = "8397d8fd-e80d-48ea-bf79-81f32b12606e";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getNodeRelationship(nodeRelationshipId, callback);

Example Response

{
    "id": "8397d8fd-e80d-48ea-bf79-81f32b12606e",
    "create_date": "2018-03-26T19:54:31.000+0000",
    "update_date": "2018-03-26T19:54:31.000+0000",
    "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
    "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
    "value": "high",
    "is_leaf": false,
    "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "metadata": {}
}

Retrieve the information for a node relationship. The node_relationship_id must be provided. The endpoint returns the node_relationship_id and the details for the node relationship specified.

HTTP REQUEST

GET /node_relationship/{node_relationship_id}

Update a node relationship

Example Request

curl -X PUT -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      -H "Content-Type: application/json" \
      -d '{
              "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
              "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
              "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
              "value": "high",
              "is_leaf": true,
              "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3"
        }' "https://api.hydrogenplatform.com/nucleus/v1/node_relationship/8397d8fd-e80d-48ea-bf79-81f32b12606e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'
payload = atom_api.NodeRelationshipPayload(node_parent_id="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
   node_child_id="d5011ba6-50c6-427b-a29c-b7802a2c8660",
   answer_id="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
   value="high",
   is_leaf=True,
   decision_tree_id="28021071-bece-400b-a0f6-23fb13adfcd3")

try:
    # Update a node relationship
    api_response = api_instance.update_node_relationship(node_relationship_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_node_relationship: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'

payload = AtomApi::NodeRelationshipPayload.new
payload.node_parent_id = "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62"
payload.node_child_id = "d5011ba6-50c6-427b-a29c-b7802a2c8660"
payload.answer_id = "556cedaa-37ba-4dc7-ad03-0990b9252e1d"
payload.value = "high"
payload.is_leaf = true
payload.decision_tree_id = "28021071-bece-400b-a0f6-23fb13adfcd3"

begin
  #Update a node relationship
  result = api_instance.update_node_relationship(node_relationship_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_node_relationship: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeRelationshipId = new UUID("8397d8fd-e80d-48ea-bf79-81f32b12606e");
NodeRelationshipPayload payload = new NodeRelationshipPayload(nodeParentId="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    nodeChildId="d5011ba6-50c6-427b-a29c-b7802a2c8660",
    answerId="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
    value="high",
    isLeaf=true,
    decisionTreeId="28021071-bece-400b-a0f6-23fb13adfcd3");
try {
    SpecificNodeRelationshipResponse result = apiInstance.updateNodeRelationship(nodeRelationshipId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateNodeRelationship");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeRelationshipId = "8397d8fd-e80d-48ea-bf79-81f32b12606e";

var payload = new atom_api.NodeRelationshipPayload(nodeParentId="05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
   nodeChildId="d5011ba6-50c6-427b-a29c-b7802a2c8660",
   answerId="556cedaa-37ba-4dc7-ad03-0990b9252e1d",
   value="high",
   isLeaf=true,
   decisionTreeId="28021071-bece-400b-a0f6-23fb13adfcd3");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateNodeRelationship(nodeRelationshipIdpayload, callback);

Example Response

{
    "id": "8397d8fd-e80d-48ea-bf79-81f32b12606e",
    "create_date": "2018-03-26T19:54:31.000+0000",
    "update_date": "2018-03-26T19:54:31.000+0000",
    "node_parent_id": "05b9f2e6-aabc-44b5-8e02-f1ab216ebd62",
    "node_child_id": "d5011ba6-50c6-427b-a29c-b7802a2c8660",
    "answer_id": "556cedaa-37ba-4dc7-ad03-0990b9252e1d",
    "value": "high",
    "is_leaf": true,
    "decision_tree_id": "28021071-bece-400b-a0f6-23fb13adfcd3",
    "metadata": {}
}

Update the information for a node relationship. The node_relationship_id must be provided. To obtain the appropriate node_relationship_id, use the GET /node_relationship endpoint to view all the node relationships defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the node_relationship_id and the details for the node relationship.

HTTP REQUEST

PUT /node_relationship/{node_relationship_id}

Delete a node relationship

Example Request

curl -X DELETE -H "Authorization: Bearer 921c2e12-c3c3-4fe5-b8cc-2035d39ad44e" \
      "https://api.hydrogenplatform.com/nucleus/v1/node_relationship/8397d8fd-e80d-48ea-bf79-81f32b12606e"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'

try:
    # Delete a node relationship
    api_instance.delete_node_relationship(node_relationship_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_node_relationship: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

node_relationship_id = '8397d8fd-e80d-48ea-bf79-81f32b12606e'

begin
  #Delete a node relationship
  api_instance.delete_node_relationship(node_relationship_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_node_relationship: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID nodeRelationshipId = new UUID("8397d8fd-e80d-48ea-bf79-81f32b12606e");
try {
    apiInstance.deleteNodeRelationship(nodeRelationshipId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteNodeRelationship");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var nodeRelationshipId = "8397d8fd-e80d-48ea-bf79-81f32b12606e";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteNodeRelationship(nodeRelationshipId, callback);

Response (204 No Content)

Permanently delete a node relationship. The node_relationship_id must be provided. To obtain the appropriate node_relationship_id, use the GET /node_relationship endpoint to view all the node relationships defined for your firm. This deletes the node_relationship_id and the details for the node relationship.

HTTP REQUEST

DELETE /node_relationship/{node_relationship_id}

Questionnaire

Questionnaires represent a series of questions that a customer or user can answer to help in the selection or customization of a product. For example, it can be an investment risk profile questionnaire that helps determine a client’s risk profile and the appropriate allocations or models for him/her. Questionnaires can also be assigned to goals and represent the questions a client must answer to customize their goal. The answer values provided to questions from a client are stored as client responses. Questions can be answered so that they only apply to a specific account, or they can be answered to apply to a client as a whole so that the client does not have to answer the same question multiple times.

Field Type Description
id UUID The id of the questionnaire
name string Name for the questionnaire
description string Descriptions for additional information on the questionnaire
decision_tree_id UUID The id of the decision tree that corresponds to the questionnaire
type string Type of questionnaire such as “retirement plan”
questions array List of questions to be answered as well as their respective answers and weights within the questionnaire
      id string The id of the question
      category string A category for the question such as “Onboarding” or “Risk Profile”
      subcategory string A subcategory for the question such as “Income-related”
      title string Title for the question such as the body of the question or a header. Pairs with the description field
      description string Description for the question such as additioonal question content. Pairs with the title field
      question_type string The type of question structure such as “multiple_choice” or “free_form”
      order_index string The order of the question within the questionnaire or category such as “1”, “2”, “3”
      document string A reference link to a document related to the question
      image string A reference link to an image associated with the question
      weight float The weight of the question as a percentage of the total questionnaire if each question does not contribute equally when calculating the final “score”; ex. 20 representing 20%. Weights of all the questions must add up to 100
      is_account boolean Indicates if the question is answered at an account-level
      metadata hash Custom information associated with the question in the format key:value. See Metadata
      answers array Possible answers to the question such as multiple choice options
            id string The id of the answer option
            value string Value for the answer option
            order_index string The order of the answer option within the question or category such as “1”, “2”, “3”
            label string A label to be assigned to the answer option for data labeling purposes
            image string A reference link to an image associated with the answer option
            weight float The weight of the answer option as a percentage of the total questionnaire score if each answer does not contribute equally when calculating the final “score”; ex. 20 representing 20%. Weights of all the answers for a question must add up to 100
            is_default boolean Indicates the default answer to a question in a questionnaire when the UI is displayed to a user. Defaults to false
            metadata hash Custom information associated with the answer options in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all questionnaires

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/questionnaire"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all questionnaires
    api_response = api_instance.get_questionnaires()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_questionnaires: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all questionnaires
  result = api_instance.get_questionnaires()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_questionnaires: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetQuestionnaireResponse result = apiInstance.getQuestionnaires();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getQuestionnaires");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getQuestionnaires(opts, callback);

Example Response

{
    "content": [
        {
            "id": "29fa5156-cd89-4056-9125-ce2428b05f11",
            "create_date": "2018-01-01T21:56:03.000+0000",
            "update_date": "2018-01-15T21:56:03.000+0000",
            "name": "Onboarding Questionnaire",
            "description": "Basic goals onboarding for accounts",
            "type": "Goals",
            "questions": [
                {
                    "id": "df392582-514f-486b-b15b-fecba66a104f",
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your age?",
                    "question_type": "free_form",
                    "order_index": "1",
                    "document": "http://domain.com/legal_agreement.pdf",
                    "image": "http://domain.com/age_graphic.pdf",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "id": "d31c694f-bcb5-427f-b081-91e64e90229a",
                            "value": ">40",
                            "image": "http://domain.com/age_graphic1.pdf",
                            "weight": 0,
                            "is_default": false,
                            "metadata": {}
                        },
                        {
                            "id": "1e52401f-bfec-410b-bca1-afa5f0be37b5",
                            "value": "0-40",
                            "image": "http://domain.com/age_graphic2.pdf",
                            "weight": 0,
                            "is_default": false,
                            "metadata": {}
                        }
                    ],
                    "metadata": {}
                },
                {
                    "id": "65fabce6-c7a3-464c-99a2-717008f4acfe",
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your annual income in dollars?",
                    "question_type": "monetary_input",
                    "order_index": "2",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "id": "7d8de5fa-6174-4a30-9e70-8e638a3d5304",
                            "value": ">100,000",
                            "image": "http://domain.com/income_graphic1.pdf",
                            "label": "high_net_worth",
                            "weight": 0,
                            "is_default": false,
                            "metadata": {}
                        },
                        {
                            "id": "0ffe04ba-5db0-4a72-9fd1-2ba9479e685a",
                            "value": "0-100,000",
                            "image": "http://domain.com/income_graphic2.pdf",
                            "weight": 0,
                            "is_default": false,
                            "metadata": {}
                        }
                    ],
                    "metadata": {}
                }
            ]
      }
     ],
    "last": false,
    "total_pages": 1,
    "total_elements": 1,
    "sort": [
        {
            "direction": "ASC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": false,
            "ascending": true
        }
    ],
    "first": true,
    "number_of_elements": 1,
    "size": 25,
    "number": 0
}

Get the information for all questionnaires defined for your firm. You can filter using a decision_tree_id to view the questionnaire associated with a specific decision tree. To obtain the appropriate decision_tree_id, use the GET /decision_tree endpoint to view all decision trees defined for your firm. Note that the questionnaire metadata information and the questions are stored as nested objects within the questionnaire object. The question metadata and the answers are a nested objects within the question object, and the answer metadata is a nested object within the answer object.

HTTP REQUEST

GET /questionnaire

Create a questionnaire

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900"
     -H "Content-Type: application/json"
     -d '{
            "name": "Onboarding Questionnaire",
            "description": "Basic goals onboarding for accounts",
            "type": "Goals",
            "questions": [
                {
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your age?",
                    "question_type": "free_form",
                    "order_index": "1",
                    "document": "http://domain.com/legal_agreement.pdf",
                    "image": "http://domain.com/age_graphic.pdf",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "value": ">40",
                            "image": "http://domain.com/age_graphic1.pdf",
                            "weight": 0
                        },
                        {
                            "value": "0-40",
                            "image": "http://domain.com/age_graphic2.pdf",
                            "weight": 0
                        }
                    ]
                },
                {
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your annual income in dollars?",
                    "question_type": "monetary_input",
                    "order_index": "2",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "value": ">100,000",
                            "image": "http://domain.com/income_graphic1.pdf",
                            "label": "high_net_worth",
                            "weight": 0
                        },
                        {
                            "value": "0-100,000",
                            "image": "http://domain.com/income_graphic2.pdf",
                            "weight": 0
                        }
                    ]
                }
            ]
      }' "https://api.hydrogenplatform.com/nucleus/v1/questionnaire"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

question_one_answer_one = atom_api.QuestionnairePayloadAnswers(value=">40",
   image="http://domain.com/age_graphic1.pdf",
   weight=0)
question_one_answer_two = atom_api.QuestionnairePayloadAnswers(value="0-40",
   image="http://domain.com/age_graphic2.pdf",
   weight=0)
question_one = atom_api.QuestionnairePayloadQuestions(category="Onboarding",
  subcategory="Basic"
  title="What is your age?",
  question_type="free_form",
  order_index="1",
  document="http://domain.com/legal_agreement.pdf",
  image="http://domain.com/age_graphic.pdf",
  weight=0,
  is_account=False,
  answers=[question_one_answer_one, question_one_answer_two])

question_two_answer_one = atom_api.QuestionnairePayloadAnswers(value=">100,000",
   image="http://domain.com/income_graphic1.pdf",
   weight=0)
question_two_answer_two = atom_api.QuestionnairePayloadAnswers(value="0-100,000",
   image="http://domain.com/income_graphic2.pdf",
   weight=0)
question_two = atom_api.QuestionnairePayloadQuestions(category="Onboarding",
  subcategory="Basic"
  title="What is your annual income in dollars?",
  question_type="monetary_input",
  order_index="2",
  document="http://domain.com/legal_agreement.pdf",
  image="http://domain.com/age_graphic.pdf",
  weight=0,
  is_account=False,
  answers=[question_two_answer_one, question_two_answer_two])

payload = atom_api.QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[question_one, question_two])

try:
    # Create a questionnaire
    api_response = api_instance.post_questionnaire(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_questionnaire: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::QuestionnairePayload.new
payload.name = "Onboarding Questionnaire"
payload.description = "Basic goals onboarding for accounts"
payload.type = "Goals"

question_one = AtomApi::QuestionnairePayloadQuestions.new
question_one.category = "Onboarding"
question_one.subcategory = "Basic"
question_one.title = "What is your age?"
question_one.question_type = "free_form"
question_one.order_index = "1"
question_one.document = "http://domain.com/legal_agreement.pdf"
question_one.image = "http://domain.com/age_graphic.pdf"
question_one.weight = 0
question_one.is_account = false

question_one_answer_one = AtomApi::QuestionnairePayloadAnswers.new
question_one_answer_one.value = ">40"
question_one_answer_one.image = "http://domain.com/age_graphic1.pdf"
question_one_answer_one.weight = 0
question_one_answer_two = AtomApi::QuestionnairePayloadAnswers.new
question_one_answer_two.value = "0-40"
question_one_answer_two.image = "http://domain.com/age_graphic2.pdf"
question_one_answer_two.weight = 0

question_one.answers = [question_one_answer_one, question_one_answer_two]

question_two = AtomApi::QuestionnairePayloadQuestions.new
question_two.category = "Onboarding"
question_two.subcategory = "Basic"
question_two.title = "What is your annual income in dollars?"
question_two.question_type = "monetary_input"
question_two.order_index = "2"
question_two.weight = 0
question_two.is_account = false

question_two_answer_one = AtomApi::QuestionnairePayloadAnswers.new
question_two_answer_one.value = ">100,000"
question_two_answer_one.image = "http://domain.com/income_graphic1.pdf"
question_two_answer_one.label = "high_net_worth"
question_two_answer_one.weight = 0
question_two_answer_two = AtomApi::QuestionnairePayloadAnswers.new
question_two_answer_two.value = "0-100,000"
question_two_answer_two.image = "http://domain.com/income_graphic2.pdf"
question_two_answer_two.weight = 0

question_two.answers = [question_two_answer_one, question_two_answer_two]

payload.questions = [question_one, question_two]

begin
  #Create a questionnaire
  result = api_instance.post_questionnaire(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_questionnaire: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
QuestionnairePayloadAnswers answer1 = new QuestionnairePayloadAnswers(value=">40",
      image="http://domain.com/age_graphic1.pdf",
      weight=0);
QuestionnairePayloadAnswers answer2 = new QuestionnairePayloadAnswers(value="0-40",
      image="http://domain.com/age_graphic2.pdf",
      weight=0);
QuestionnairePayloadQuestions quest1 = new QuestionnairePayloadQuestions(category="Onboarding",
     subcategory="Basic",
     title="What is your age?",
     questionType="free_form",
     order_index="1",
     document="http://domain.com/legal_agreement.pdf",
     image="http://domain.com/age_graphic.pdf",
     weight=0,
     isAccount=false,
     answers=[answer1, answer2]);
QuestionnairePayloadAnswers answer3 = new QuestionnairePayloadAnswers(value=">100,000",
      image="http://domain.com/income_graphic1.pdf",
      label="high_net_worth",
      weight=0);
QuestionnairePayloadAnswers answer4 = new QuestionnairePayloadAnswers(value="0-100,000",
      image="http://domain.com/income_graphic2.pdf",
      weight=0);
QuestionnairePayloadQuestions quest2 = new QuestionnairePayloadQuestions(category="Onboarding",
     subcategory="Basic",
     title="What is your annual income in dollars?",
     questionType="monetary_input",
     order_index="2",
     weight=0,
     isAccount=false,
     answers=[answer3, answer4]);
QuestionnairePayload payload = new QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[quest1, quest2]);
try {
    CreateQuestionnaireResponse result = apiInstance.postQuestionnaire(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postQuestionnaire");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var answer1 = new QuestionnairePayloadAnswers(value=">40",
  image="http://domain.com/age_graphic1.pdf",
  weight=0);
var answer2 = new QuestionnairePayloadAnswers(value="0-40",
    image="http://domain.com/age_graphic2.pdf",
    weight=0);
var quest1 = new QuestionnairePayloadQuestions(category="Onboarding",
   subcategory="Basic",
   title="What is your age?",
   questionType="free_form",
   order_index="1",
   document="http://domain.com/legal_agreement.pdf",
   image="http://domain.com/age_graphic.pdf",
   weight=0,
   isAccount=false,
   answers=[answer1, answer2]);
var answer3 = new QuestionnairePayloadAnswers(value=">100,000",
  image="http://domain.com/income_graphic1.pdf",
  label="high_net_worth",
  weight=0);
var answer4 = new QuestionnairePayloadAnswers(value="0-100,000",
  image="http://domain.com/income_graphic2.pdf",
  weight=0);
var quest2 = new QuestionnairePayloadQuestions(category="Onboarding",
   subcategory="Basic",
   title="What is your annual income in dollars?",
   questionType="monetary_input",
   order_index="2",
   weight=0,
   isAccount=false,
   answers=[answer3, answer4]);
var payload = new atom_api.QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[quest1, quest2]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postQuestionnaire(payload, callback);

Example Response

{
    "id": "29fa5156-cd89-4056-9125-ce2428b05f11",
    "create_date": "2018-01-01T21:56:03.000+0000",
    "name": "Onboarding Questionnaire",
    "description": "Basic goals onboarding for accounts",
    "type": "Goals",
    "questions": [
        {
            "id": "df392582-514f-486b-b15b-fecba66a104f",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your age?",
            "question_type": "free_form",
            "order_index": "1",
            "document": "http://domain.com/legal_agreement.pdf",
            "image": "http://domain.com/age_graphic.pdf",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "d31c694f-bcb5-427f-b081-91e64e90229a",
                    "value": ">40",
                    "image": "http://domain.com/age_graphic1.pdf",
                    "weight": 0,
                    "metadata": {}
                },
                {
                    "id": "1e52401f-bfec-410b-bca1-afa5f0be37b5",
                    "value": "0-40",
                    "image": "http://domain.com/age_graphic2.pdf",
                    "weight": 0,
                    "metadata": {}
                }
            ],
            "metadata": {}
        },
        {
            "id": "65fabce6-c7a3-464c-99a2-717008f4acfe",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your annual income in dollars?",
            "question_type": "monetary_input",
            "order_index": "2",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "7d8de5fa-6174-4a30-9e70-8e638a3d5304",
                    "value": ">100,000",
                    "image": "http://domain.com/income_graphic1.pdf",
                    "label": "high_net_worth",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                },
                {
                    "id": "0ffe04ba-5db0-4a72-9fd1-2ba9479e685a",
                    "value": "0-100,000",
                    "image": "http://domain.com/income_graphic2.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                }
            ],
            "metadata": {}
        }
    ]
}

Create a new questionnaire for your firm. A name for the questionnaire and the embedded questions and answers must be provided. The endpoint returns a questionnaire_id to manage the questionnaire and assign it to goals.

HTTP REQUEST

POST /questionnaire

ARGUMENTS

Parameter Type Required Description
name string required Name for the questionnaire
description string optional Descriptions for additional information on the questionnaire
decision_tree_id UUID optional The id of the decision tree that corresponds to the questionnaire
type string optional Type of questionnaire such as “retirement plan”
questions array optional List of questions to be answered as well as their respective answers and weights within the questionnaire
      category string optional A category for the question such as “Onboarding” or “Risk Profile”
      subcategory string optional A subcategory for the question such as “Income-related”
      title string optional Title for the question such as the body of the question or a header. Pairs with the description field
      description string optional Description for the question such as additioonal question content. Pairs with the title field
      question_type string optional The type of question structure such as “multiple_choice” or “free_form”
      order_index string optional The order of the question within the questionnaire or category such as “1”, “2”, “3”
      document string optional A reference link to a document related to the question
      image string optional A reference link to an image associated with the question
      weight float optional The weight of the question as a percentage of the total questionnaire if each question does not contribute equally when calculating the final “score”; ex. 20 representing 20%. Weights of all the questions must add up to 100
      is_account boolean optional Indicates if the question is answered at an account-level
      metadata hash optional Custom information associated with the question in the format key:value. See Metadata
      answers array optional Possible answers to the question such as multiple choice options
            value string required Value for the answer option
            order_index string optional The order of the answer option within the question or category such as “1”, “2”, “3”
            label string optional A label to be assigned to the answer option for data labeling purposes
            image string optional A reference link to an image associated with the answer option
            weight float optional The weight of the answer option as a percentage of the total questionnaire score if each answer does not contribute equally when calculating the final “score”; ex. 20 representing 20%. Weights of all the answers for a question must add up to 100
            is_default boolean optional Indicates the default answer to a question in a questionnaire when the UI is displayed to a user. Defaults to false
            metadata hash optional Custom information associated with the answer option in the format key:value. See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a questionnaire

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/questionnaire/29fa5156-cd89-4056-9125-ce2428b05f11"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
questionnaire_id = '29fa5156-cd89-4056-9125-ce2428b05f11'

try:
    # Retrieve a questionnaire
    api_response = api_instance.get_questionnaire(questionnaire_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_questionnaire: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

questionnaire_id = '29fa5156-cd89-4056-9125-ce2428b05f11'

begin
  #Retrieve a questionnaire
  result = api_instance.get_questionnaire(questionnaire_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_questionnaire: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID questionnaireId = new UUID("29fa5156-cd89-4056-9125-ce2428b05f11");
try {
    SpecificQuestionnaireResponse result = apiInstance.getQuestionnaire(questionnaireId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getQuestionnaire");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var questionnaireId = "29fa5156-cd89-4056-9125-ce2428b05f11";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getQuestionnaire(questionnaireId, callback);

Example Response

{
    "id": "29fa5156-cd89-4056-9125-ce2428b05f11",
    "create_date": "2018-01-01T21:56:03.000+0000",
    "update_date": "2018-01-15T21:56:03.000+0000",
    "name": "Onboarding Questionnaire",
    "description": "Basic goals onboarding for accounts",
    "type": "Goals",
    "questions": [
        {
            "id": "df392582-514f-486b-b15b-fecba66a104f",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your age?",
            "question_type": "free_form",
            "order_index": "1",
            "document": "http://domain.com/legal_agreement.pdf",
            "image": "http://domain.com/age_graphic.pdf",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "d31c694f-bcb5-427f-b081-91e64e90229a",
                    "value": ">40",
                    "image": "http://domain.com/age_graphic1.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                },
                {
                    "id": "1e52401f-bfec-410b-bca1-afa5f0be37b5",
                    "value": "0-40",
                    "image": "http://domain.com/age_graphic2.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                }
            ],
            "metadata": {}
        },
        {
            "id": "65fabce6-c7a3-464c-99a2-717008f4acfe",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your annual income in dollars?",
            "question_type": "monetary_input",
            "order_index": "2",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "7d8de5fa-6174-4a30-9e70-8e638a3d5304",
                    "value": ">100,000",
                    "image": "http://domain.com/income_graphic1.pdf",
                    "label": "high_net_worth",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                },
                {
                    "id": "0ffe04ba-5db0-4a72-9fd1-2ba9479e685a",
                    "value": "0-100,000",
                    "image": "http://domain.com/income_graphic2.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                }
            ],
            "metadata": {}
        }
    ]
}

Retrieve the information for a questionnaire for your firm. The questionnaire_id must be provided. The endpoint returns the questionnaire_id and the details for the questionnaire specified.

HTTP REQUEST

GET /questionnaire/{questionnaire_id}

Update a questionnaire

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900"
    -H "Content-Type: application/json"
    -d '{
            "name": "Onboarding Questionnaire",
            "description": "Basic goals onboarding for accounts",
            "type": "Goals",
            "questions": [
                {
                    "id": "df392582-514f-486b-b15b-fecba66a104f",
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your age?",
                    "question_type": "free_form",
                    "order_index": "1",
                    "document": "http://domain.com/legal_agreement.pdf",
                    "image": "http://domain.com/age_graphic.pdf",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "id": "d31c694f-bcb5-427f-b081-91e64e90229a",
                            "value": ">40",
                            "image": "http://domain.com/age_graphic1.pdf",
                            "weight": 0
                        },
                        {
                            "id": "1e52401f-bfec-410b-bca1-afa5f0be37b5",
                            "value": "0-40",
                            "image": "http://domain.com/age_graphic2.pdf",
                            "weight": 0
                        }
                    ]
                },
                {
                    "id": "65fabce6-c7a3-464c-99a2-717008f4acfe",
                    "category": "Onboarding",
                    "subcategory": "Basic",
                    "title": "What is your annual income in dollars?",
                    "question_type": "monetary_input",
                    "order_index": "2",
                    "weight": 0,
                    "is_account": false,
                    "answers": [
                        {
                            "id": "7d8de5fa-6174-4a30-9e70-8e638a3d5304",
                            "value": ">100,000",
                            "image": "http://domain.com/income_graphic1.pdf",
                            "label": "high_net_worth",
                            "weight": 0
                        },
                        {
                            "id": "0ffe04ba-5db0-4a72-9fd1-2ba9479e685a",
                            "value": "0-100,000",
                            "image": "http://domain.com/income_graphic2.pdf",
                            "weight": 0
                        }
                    ]
                }
            ]
      }' "https://api.hydrogenplatform.com/nucleus/v1/questionnaire/29fa5156-cd89-4056-9125-ce2428b05f11"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
questionnaire_id = '29fa5156-cd89-4056-9125-ce2428b05f11'

question_one_answer_one = atom_api.QuestionnairePayloadAnswers(value=">40",
   image="http://domain.com/age_graphic1.pdf",
   weight=0)
question_one_answer_two = atom_api.QuestionnairePayloadAnswers(value="0-40",
   image="http://domain.com/age_graphic2.pdf",
   weight=0)
question_one = atom_api.QuestionnairePayloadQuestions(category="Onboarding",
  subcategory="Basic"
  title="What is your age?",
  question_type="free_form",
  order_index="1",
  document="http://domain.com/legal_agreement.pdf",
  image="http://domain.com/age_graphic.pdf",
  weight=0,
  is_account=False,
  answers=[question_one_answer_one, question_one_answer_two])

question_two_answer_one = atom_api.QuestionnairePayloadAnswers(value=">100,000",
   image="http://domain.com/income_graphic1.pdf",
   weight=0)
question_two_answer_two = atom_api.QuestionnairePayloadAnswers(value="0-100,000",
   image="http://domain.com/income_graphic2.pdf",
   weight=0)
question_two = atom_api.QuestionnairePayloadQuestions(category="Onboarding",
  subcategory="Basic"
  title="What is your annual income in dollars?",
  question_type="monetary_input",
  order_index="2",
  document="http://domain.com/legal_agreement.pdf",
  image="http://domain.com/age_graphic.pdf",
  weight=0,
  is_account=False,
  answers=[question_two_answer_one, question_two_answer_two])

payload = atom_api.QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[question_one, question_two])

try:
    # Update a questionnaire
    api_response = api_instance.update_questionnaire(questionnaire_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_questionnaire: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

questionnaire_id = '29fa5156-cd89-4056-9125-ce2428b05f11'

payload = AtomApi::QuestionnairePayload.new
payload.name = "Onboarding Questionnaire"
payload.description = "Basic goals onboarding for accounts"
payload.type = "Goals"

question_one = AtomApi::QuestionnairePayloadQuestions.new
question_one.category = "Onboarding"
question_one.subcategory = "Basic"
question_one.title = "What is your age?"
question_one.question_type = "free_form"
question_one.order_index = "1"
question_one.document = "http://domain.com/legal_agreement.pdf"
question_one.image = "http://domain.com/age_graphic.pdf"
question_one.weight = 0
question_one.is_account = false

question_one_answer_one = AtomApi::QuestionnairePayloadAnswers.new
question_one_answer_one.value = ">40"
question_one_answer_one.image = "http://domain.com/age_graphic1.pdf"
question_one_answer_one.weight = 0
question_one_answer_two = AtomApi::QuestionnairePayloadAnswers.new
question_one_answer_two.value = "0-40"
question_one_answer_two.image = "http://domain.com/age_graphic2.pdf"
question_one_answer_two.weight = 0

question_one.answers = [question_one_answer_one, question_one_answer_two]

question_two = AtomApi::QuestionnairePayloadQuestions.new
question_two.category = "Onboarding"
question_two.subcategory = "Basic"
question_two.title = "What is your annual income in dollars?"
question_two.question_type = "monetary_input"
question_two.order_index = "2"
question_two.weight = 0
question_two.is_account = false

question_two_answer_one = AtomApi::QuestionnairePayloadAnswers.new
question_two_answer_one.value = ">100,000"
question_two_answer_one.image = "http://domain.com/income_graphic1.pdf"
question_two_answer_one.label = "high_net_worth"
question_two_answer_one.weight = 0
question_two_answer_two = AtomApi::QuestionnairePayloadAnswers.new
question_two_answer_two.value = "0-100,000"
question_two_answer_two.image = "http://domain.com/income_graphic2.pdf"
question_two_answer_two.weight = 0

question_two.answers = [question_two_answer_one, question_two_answer_two]

payload.questions = [question_one, question_two]

begin
  #Update a questionnaire
  result = api_instance.update_questionnaire(questionnaire_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_questionnaire: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID questionnaireId = new UUID("29fa5156-cd89-4056-9125-ce2428b05f11");
QuestionnairePayloadAnswers answer1 = new QuestionnairePayloadAnswers(value=">40",
      image="http://domain.com/age_graphic1.pdf",
      weight=0);
QuestionnairePayloadAnswers answer2 = new QuestionnairePayloadAnswers(value="0-40",
      image="http://domain.com/age_graphic2.pdf",
      weight=0);
QuestionnairePayloadQuestions quest1 = new QuestionnairePayloadQuestions(category="Onboarding",
     subcategory="Basic",
     title="What is your age?",
     questionType="free_form",
     order_index="1",
     document="http://domain.com/legal_agreement.pdf",
     image="http://domain.com/age_graphic.pdf",
     weight=0,
     isAccount=false,
     answers=[answer1, answer2]);
QuestionnairePayloadAnswers answer3 = new QuestionnairePayloadAnswers(value=">100,000",
      image="http://domain.com/income_graphic1.pdf",
      label="high_net_worth",
      weight=0);
QuestionnairePayloadAnswers answer4 = new QuestionnairePayloadAnswers(value="0-100,000",
      image="http://domain.com/income_graphic2.pdf",
      weight=0);
QuestionnairePayloadQuestions quest2 = new QuestionnairePayloadQuestions(category="Onboarding",
     subcategory="Basic",
     title="What is your annual income in dollars?",
     questionType="monetary_input",
     order_index="2",
     weight=0,
     isAccount=false,
     answers=[answer3, answer4]);
QuestionnairePayload payload = new QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[quest1, quest2]);
try {
    SpecificQuestionnaireResponse result = apiInstance.updateQuestionnaire(questionnaireId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateQuestionnaire");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var questionnaireId = "29fa5156-cd89-4056-9125-ce2428b05f11";

var answer1 = new QuestionnairePayloadAnswers(value=">40",
  image="http://domain.com/age_graphic1.pdf",
  weight=0);
var answer2 = new QuestionnairePayloadAnswers(value="0-40",
  image="http://domain.com/age_graphic2.pdf",
  weight=0);
var quest1 = new QuestionnairePayloadQuestions(category="Onboarding",
    subcategory="Basic",
    title="What is your age?",
    questionType="free_form",
    order_index="1",
    document="http://domain.com/legal_agreement.pdf",
    image="http://domain.com/age_graphic.pdf",
    weight=0,
    isAccount=false,
    answers=[answer1, answer2]);
var answer3 = new QuestionnairePayloadAnswers(value=">100,000",
      image="http://domain.com/income_graphic1.pdf",
      label="high_net_worth",
      weight=0);
var answer4 = new QuestionnairePayloadAnswers(value="0-100,000",
      image="http://domain.com/income_graphic2.pdf",
      weight=0);
var quest2 = new QuestionnairePayloadQuestions(category="Onboarding",
   subcategory="Basic",
   title="What is your annual income in dollars?",
   questionType="monetary_input",
   order_index="2",
   weight=0,
   isAccount=false,
   answers=[answer3, answer4]);
var payload = new atom_api.QuestionnairePayload(name="Onboarding Questionnaire",
    description="Basic goals onboarding for accounts",
    type="Goals",
    questions=[quest1, quest2]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateQuestionnaire(questionnaireIdpayload, callback);

Example Response

{
    "id": "29fa5156-cd89-4056-9125-ce2428b05f11",
    "create_date": "2018-01-01T21:56:03.000+0000",
    "update_date": "2018-01-15T21:56:03.000+0000",
    "name": "Onboarding Questionnaire",
    "description": "Basic goals onboarding for accounts",
    "type": "Goals",
    "questions": [
        {
            "id": "df392582-514f-486b-b15b-fecba66a104f",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your age?",
            "question_type": "free_form",
            "order_index": "1",
            "document": "http://domain.com/legal_agreement.pdf",
            "image": "http://domain.com/age_graphic.pdf",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "d31c694f-bcb5-427f-b081-91e64e90229a",
                    "value": ">40",
                    "image": "http://domain.com/age_graphic1.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                },
                {
                    "id": "1e52401f-bfec-410b-bca1-afa5f0be37b5",
                    "value": "0-40",
                    "image": "http://domain.com/age_graphic2.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                }
            ],
            "metadata": {}
        },
        {
            "id": "65fabce6-c7a3-464c-99a2-717008f4acfe",
            "category": "Onboarding",
            "subcategory": "Basic",
            "title": "What is your annual income in dollars?",
            "question_type": "monetary_input",
            "order_index": "2",
            "weight": 0,
            "is_account": false,
            "answers": [
                {
                    "id": "7d8de5fa-6174-4a30-9e70-8e638a3d5304",
                    "value": ">100,000",
                    "image": "http://domain.com/income_graphic1.pdf",
                    "label": "high_net_worth",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                },
                {
                    "id": "0ffe04ba-5db0-4a72-9fd1-2ba9479e685a",
                    "value": "0-100,000",
                    "image": "http://domain.com/income_graphic2.pdf",
                    "weight": 0,
                    "is_default": false,
                    "metadata": {}
                }
            ],
            "metadata": {}
        }
    ]
}

Update a questionnaire for your firm. The questionnaire_id must be provided in the URL. To obtain the appropriate questionnaire_id, use the GET /questionnaire endpoint to view all questionnaires for your firm and their current information. The endpoint returns the questionnaire_id and the details for the questionnaire. Due to the embedded questions and answers structure, to make specific updates or changes there are particular combinations of information that must be provided in addition to the questionnaire_id:

  1. Update the details of a question and/or answer:
   a. Provide the questionnaire_id in the URL and the details about the questionnaire to be updated (if any) such as name
   b. Provide the question_id and existing details for all questions to remain the same
   c. Provide the answer_id and existing details for all answers to remain the same
   d. Provide the question_id and new details for all questions to be updated
   e. Provide the answer_id and new details for all answers to be updated
  2. Remove a question and/or answer:
   a. Provide the questionnaire_id in the URL and the details about the questionnaire to be updated (if any) such as name
   b. Provide the question_id and existing details for all questions to remain the same
   c. Provide the answer_id and existing details for all answers to remain the same
   d. Provide the question_id for the questions to be removed with no additional details
   e. Provide the answer_id for the answers to be removed with no additional details
  3. Replace all questions and answers and generate new question_ids and answer_ids:
   a. Provide the questionnaire_id in the URL and the details about the questionnaire to be updated (if any) such as name
   b. Provide the details for all of the new questions and answers with no question_ids and answer_ids
  4. Delete all questions and answers:
   a. Provide the questionnaire_id in the URL and the details about the questionnaire to be updated (if any) such as name
   b. Provide the question_ids and answer_ids for all the questions and answers with no additional details

HTTP REQUEST

PUT /questionnaire/{questionnaire_id}

Delete a questionnaire

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/questionnaire/429fa5156-cd89-4056-9125-ce2428b05f11"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
questionnaire_id = '429fa5156-cd89-4056-9125-ce2428b05f11'

try:
    # Delete a questionnaire
    api_instance.delete_questionnaire(questionnaire_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_questionnaire: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

questionnaire_id = '429fa5156-cd89-4056-9125-ce2428b05f11'

begin
  #Delete a questionnaire
  api_instance.delete_questionnaire(questionnaire_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_questionnaire: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID questionnaireId = new UUID("429fa5156-cd89-4056-9125-ce2428b05f11");
try {
    apiInstance.deleteQuestionnaire(questionnaireId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteQuestionnaire");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var questionnaireId = "429fa5156-cd89-4056-9125-ce2428b05f11";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteQuestionnaire(questionnaireId, callback);

Response (204 No Content)

Permanently delete a questionnaire for your firm. The questionnaire_id must be provided. To obtain the appropriate questionnaire_id, use the GET /questionnaire endpoint to view all questionnaires for your firm. This deletes the questionnaire_id and the details for the questionnaire.

HTTP REQUEST

DELETE /questionnaire/{questionnaire_id}

Score

Score is used to store scores referenced within the application. Scores may be either calculated using the Proton API or obtained from an alternate source. Scores can be stored for key entities including clients, accounts, goals, portfolios, allocations, models, benchmarks and securities. Score types that can be stored include:

1) Risk Score
2) Dimensional Risk Score
3) Diversification Score
4) Portfolio Optimization Score
5) Goal Achievement Score
6) Credit Score
7) Risk Profile

Field Type Description
id UUID The id for the score
score_type string The type of score. Values may be risk_score, dimensional_risk_score, diversification_score, portfolio_optimization_score, goal_achievement_score, credit_score, or risk_profile
score_value string The value of the score, which may be a number, a label, etc.
client_id UUID The id of a client to which the score applies (if client-specific)
account_id UUID The id of an account to which the score applies (if account-specific)
portfolio_id UUID The id of a portfolio to which the score applies (if portfolio-specific)
goal_id UUID The id of a goal to which the score applies (if goal-specific)
allocation_id UUID The id of an allocation to which the score applies (if allocation-specific)
model_id UUID The id of a model to which the score applies (if model-specific)
benchmark_id UUID The id of a benchmark to which the score applies (if benchmark-specific)
security_id UUID The id of a security to which the score applies (if security-specific)
score_time_stamp datetime Date and time for the score
metadata map Custom information associated with the score in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all scores

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
  "https://api.hydrogenplatform.com/nucleus/v1/score"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all scores
    api_response = api_instance.get_scores()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_scores: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all scores
  result = api_instance.get_scores()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_scores: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetScoreResponse result = apiInstance.getScores();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getScores");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getScores(opts, callback);

Example Response

{
    "content": [
        {    
            "id": "739ecd39-e1ae-4a0b-b266-dd3ddc616163",
            "create_date": "2018-11-01T00:00:00.000+0000",
            "score_type": "risk_score",
            "score_value": "76",
            "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
            "score_time_stamp": "2018-11-01T00:00:00.000+0000",
            "metadata": {
                "questionnaire": "Risk Profile Questionnaire"
            }
        },
        {    
            "id": "4675770f-e52b-46e2-ac4b-683adbeb034c",
            "create_date": "2017-01-01T00:00:00.000+0000",
            "score_type": "risk_score",
            "score_value": "85",
            "model_id": "89a510ad-e817-49a3-9af2-0fb59487d9ad",
            "score_time_stamp": "2017-01-01T00:00:00.000+0000",
            "metadata": {}
        }
        {    
            "id": "c0b33394-998c-4095-ad98-22551f7dbb1f",
            "create_date": "2018-11-01T00:00:00.000+0000",
            "score_type": "risk_profile",
            "score_value": "Conservative",
            "client_id": "c17cd2e1-5ecc-48e0-8f7c-5cecd9055429",
            "score_time_stamp": "2018-11-01T00:00:00.000+0000",
            "metadata": {
                "questionnaire": "Risk Profile Questionnaire"
            }
        }        
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get information for all scores stored for your firm. You can filter using one of the unique ids such as the client_id to view the scores for a client or for another particular entitiy. You can also filter by the value provided for score_time_stamp to find the scores for a specific date or date range. Note that the metadata information for the score is stored as a nested object within the score object.

HTTP REQUEST

GET /score

Create a score

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{    
          "score_type": "risk_score",
          "score_value": "76",
          "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
          "score_time_stamp": "2018-11-01T00:00:00.000+0000",
          "metadata": {
              "questionnaire": "Risk Profile Questionnaire"
          }
    }' "https://api.hydrogenplatform.com/nucleus/v1/score"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.ScorePayload(score_type="risk_score",
  score_value="76",
  client_id="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
  score_time_stamp="2018-11-01T00:00:00.000+0000",
  metadata={"questionnaire": "Risk Profile Questionnaire"})

try:
    # Create a score
    api_response = api_instance.post_score(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_score: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::ScorePayload.new
payload.score_type = "risk_score"
payload.score_value = "76"
payload.client_id = "58f90162-1bd7-4441-a1f2-cbaa4b2e3595"
payload.score_time_stamp = "2018-11-01T00:00:00.000+0000"
payload.metadata = {questionnaire = "Risk Profile Questionnaire"}

begin
  #Create a score
  result = api_instance.post_score(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_score: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
ScorePayload payload = new ScorePayload(scoreType="risk_score",
  scoreValue="76",
  clientId="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
  scoreTimeStamp="2018-11-01T00:00:00.000+0000",
  metadata={"questionnaire": "Risk Profile Questionnaire"});
try {
    CreateScoreResponse result = apiInstance.postScore(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postScore");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.ScorePayload(scoreType="risk_score",
  scoreValue="76",
  clientId="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
  scoreTimeStamp="2018-11-01T00:00:00.000+0000",
  metadata={"questionnaire": "Risk Profile Questionnaire"});

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postScore(payload, callback);

Example Response

{    
    "id": "739ecd39-e1ae-4a0b-b266-dd3ddc616163",
    "create_date": "2018-11-01T00:00:00.000+0000",
    "score_type": "risk_score",
    "score_value": "76",
    "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    "score_time_stamp": "2018-11-01T00:00:00.000+0000",
    "metadata": {
        "questionnaire": "Risk Profile Questionnaire"
    }
}

Create a score for a client, account, goal, portfolio, allocation, model, benchmark or security. The endpoint returns a score_id that can then be used to manage the score.

HTTP REQUEST

POST /score

ARGUMENTS

Parameter Type Required Description
score_type string required The type of score. Values may be risk_score, dimensional_risk_score, diversification_score, portfolio_optimization_score, goal_achievement_score, credit_score, or risk_profile
score_value string required The value of the score, which may be a number, a label, etc.
client_id UUID optional The id of a client to which the score applies (if client-specific)
account_id UUID optional The id of an account to which the score applies (if account-specific)
portfolio_id UUID optional The id of a portfolio to which the score applies (if portfolio-specific)
goal_id UUID optional The id of a goal to which the score applies (if goal-specific)
allocation_id UUID optional The id of an allocation to which the score applies (if allocation-specific)
model_id UUID optional The id of a model to which the score applies (if model-specific)
benchmark_id UUID optional The id of a benchmark to which the score applies (if benchmark-specific)
security_id UUID optional The id of a security to which the score applies (if security-specific)
score_time_stamp datetime optional Date and time for the score
metadata map optional Custom information associated with the score in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a score

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/score/739ecd39-e1ae-4a0b-b266-dd3ddc616163"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'

try:
    # Retrieve a score
    api_response = api_instance.get_score(score_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_score: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'

begin
  #Retrieve a score
  result = api_instance.get_score(score_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_score: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID scoreId = new UUID("739ecd39-e1ae-4a0b-b266-dd3ddc616163");
try {
    SpecificScoreResponse result = apiInstance.getScore(scoreId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getScore");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var scoreId = "739ecd39-e1ae-4a0b-b266-dd3ddc616163";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getScore(scoreId, callback);

Example Response

{    
    "id": "739ecd39-e1ae-4a0b-b266-dd3ddc616163",
    "create_date": "2018-11-01T00:00:00.000+0000",
    "score_type": "risk_score",
    "score_value": "76",
    "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    "score_time_stamp": "2018-11-01T00:00:00.000+0000",
    "metadata": {
        "questionnaire": "Risk Profile Questionnaire"
    }
}

Retrieve the information for a specific score associated with a client, account, goal, portfolio, allocation, model, benchmark or security. The unique score_id must be provided. The endpoint returns the score_id and details for the score specified. Note that the metadata information for the score is stored as a nested object within the score object.

HTTP REQUEST

GET /score/{score_id}

Update a score

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
-H "Content-Type: application/json" \
-d '{    
          "score_type": "risk_score",
          "score_value": "80",
          "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
          "score_time_stamp": "2018-11-01T00:00:00.000+0000",
          "metadata": {
              "questionnaire": "Risk Profile Questionnaire"
          }
    }' "https://api.hydrogenplatform.com/nucleus/v1/score/739ecd39-e1ae-4a0b-b266-dd3ddc616163"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'
payload = atom_api.ScorePayload(score_type="risk_score",
    score_value="80",
    client_id="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    score_time_stamp="2018-11-01T00:00:00.000+0000",
    metadata={"questionnaire": "Risk Profile Questionnaire"})

try:
    # Update a score
    api_response = api_instance.update_score(score_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_score: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'

payload = AtomApi::ScorePayload.new
payload.score_type = "risk_score"
payload.score_value = "80"
payload.client_id = "58f90162-1bd7-4441-a1f2-cbaa4b2e3595"
payload.score_time_stamp = "2018-11-01T00:00:00.000+0000"
payload.metadata = {questionnaire => "Risk Profile Questionnaire"}

begin
  #Update a score
  result = api_instance.update_score(score_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_score: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID scoreId = new UUID("739ecd39-e1ae-4a0b-b266-dd3ddc616163");
ScorePayload payload = new ScorePayload(scoreType="risk_score",
    scoreValue="80",
    clientId="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    scoreTimeStamp="2018-11-01T00:00:00.000+0000",
    metadata={"questionnaire": "Risk Profile Questionnaire"});
try {
    SpecificScoreResponse result = apiInstance.updateScore(scoreId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateScore");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var scoreId = "739ecd39-e1ae-4a0b-b266-dd3ddc616163";

var payload = new atom_api.ScorePayload(scoreType="risk_score",
    scoreValue="80",
    clientId="58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    scoreTimeStamp="2018-11-01T00:00:00.000+0000",
    metadata={"questionnaire": "Risk Profile Questionnaire"});

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateScore(scoreIdpayload, callback);

Example Response

{    
    "id": "739ecd39-e1ae-4a0b-b266-dd3ddc616163",
    "create_date": "2018-11-01T00:00:00.000+0000",
    "update_date": "2019-11-01T00:00:00.000+0000",
    "score_type": "risk_score",
    "score_value": "80",
    "client_id": "58f90162-1bd7-4441-a1f2-cbaa4b2e3595",
    "score_time_stamp": "2018-11-01T00:00:00.000+0000",
    "metadata": {
        "questionnaire": "Risk Profile Questionnaire"
    }
}

Update the information for a score. The unique score_id must be provided. To obtain the appropriate score_id, use the GET /score endpoint to view all scores stored for your firm and their current information. The details to be updated must also be provided. The endpoint returns the score_id and the details for the score.

HTTP REQUEST

PUT /score/{score_id}

Delete a score

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/score/739ecd39-e1ae-4a0b-b266-dd3ddc616163"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'

try:
    # Delete a score
    api_instance.delete_score(score_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_score: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

score_id = '739ecd39-e1ae-4a0b-b266-dd3ddc616163'

begin
  #Delete a score
  api_instance.delete_score(score_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_score: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID scoreId = new UUID("739ecd39-e1ae-4a0b-b266-dd3ddc616163");
try {
    apiInstance.deleteScore(scoreId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteScore");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var scoreId = "739ecd39-e1ae-4a0b-b266-dd3ddc616163";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteScore(scoreId, callback);

Response (204 No Content)

Permanently delete a score. The unique score_id must be provided. To obtain the appropriate score_id, use the GET /score endpoint to view all scores stored for your firm. This deletes the score_id and all score record information.

HTTP REQUEST

DELETE /score/{score_id}

Savings & Investing

Allocation

Allocation Management

Allocations are a collection of models to which accounts can subscribe. An account may be subscribed to one or more allocations. An allocation may have one or more accounts subscribing to it. For goals based investing/savings, an allocation may map to one goal. Allocations can also map to the nodes of a decision tree to determine which allocation(s) is/are most appropriate for an account.

Field Type Description
id UUID The id of the allocation
name string Name of the allocation
category string Category of the allocation used to group similar allocations
description string Description of the allocation
client_id UUID If the allocation is to be used by a specific client such as an advisor, the id of the client
benchmark_id UUID The id for the benchmark that the allocation should be compared to
inception_date date Date that the allocation first was managed
node_map array List of nodes in a decision tree that map to the allocation
      node_id UUID The id of the last node in the branch of a decision tree that maps to the allocation
metadata map Custom information associated with the allocation in the format key:value. See Metadata
is_active boolean Indicates if this allocation is active. Defaults to true which indicates it is active.
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

PROTON API

The following fields may optionally be used in conjunction with the Proton API. These are usually calculated via an overnight process.

Field Type Description
performance double Historical performance for the allocation, used as an input for simulations.
volatility double Historical volatility for the allocation, used as an input for simulations.

List all allocations

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
  "https://api.hydrogenplatform.com/nucleus/v1/allocation"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all allocations
    api_response = api_instance.get_allocations()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocations: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all allocations
  result = api_instance.get_allocations()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocations: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAllocationResponse result = apiInstance.getAllocations();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocations");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocations(opts, callback);

Example Response

{
"content": [
    {
        "id": "04907eaa-3f33-49be-a35b-378cdf639fba",
        "category": "Alternative",
        "description": "Hedgeable Venture Fund I, L.P. gives accredited Hedgeable clients the ability to invest in the stock of private companies in the consumer, enterprise, retail, restaurant, and other high growth fields. There is no minimum investment and no management fee or carry charged by Hedgeable.",
        "is_active": true,
        "name": "Hedgeable Venture Fund I, L.P.",
        "volatility": 0.05999999865889549,
        "performance": 0.05999999865889549,
        "node_map": [],
        "metadata": {}
    },
    {
        "id": "073def0e-6fa0-4e52-badb-6ff2aecbc2b2",
        "category": "Asset Allocation",
        "description": "",
        "is_active": true,
        "name": "Retirement Core 5",
        "volatility": 0.05999999865889549,
        "performance": 0.05999999865889549,
        "node_map": [],
        "metadata": {}
    },
    {
        "id": "013380bf-7f17-44c1-93c5-892a7ed3498c",
        "create_date": "2017-02-14T00:00:00.000+0000",
        "update_date": "2017-02-15T09:00:00.000+0000",
        "category": "Social",
        "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
        "is_active": true,
        "name": "Tax-Efficient SRI Core 2",
        "volatility": 0.0859,
        "performance": 0.0572,
        "node_map": [
            {
                "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
            },
            {
                "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
            },
            {
                "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
            }
        ],
        "metadata": {}
    }
  ],
  "last": true,
  "total_pages": 1,
  "total_elements": 2,
  "first": true,
  "sort": [
    {
        "direction": "DESC",
        "property": "id",
        "ignore_case": false,
        "null_handling": "NATIVE",
        "ascending": false,
        "descending": true
    }
  ],
  "number_of_elements": 2,
  "size": 2,
  "number": 0
}

Get details for all allocations defined for your firm. Note that the decision tree nodes and metadata information are stored as nested objects within the allocation object.

HTTP REQUEST

GET /allocation

Create an allocation

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    -d '{
            "category": "Social",
            "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
            "is_active": true,
            "name": "Tax-Efficient SRI Core 2",
            "volatility": 0.0859,
            "performance": 0.0572,
            "node_map": [
                {
                    "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
                },
                {
                    "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
                },
                {
                    "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
                }
            ],
            "metadata": {}
        }' "https://api.hydrogenplatform.com/nucleus/v1/allocation"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AllocationPayload(category="Social",
   description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
   is_active=True,
   name="Tax-Efficient SRI Core 2",
   volatility=0.0859,
   performance=0.0572,
   node_map=[
              {
                  "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
              },
              {
                  "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
              },
              {
                  "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
              }
            ])

try:
    # Create an allocation
    api_response = api_instance.post_allocation(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AllocationPayload.new
payload.category = "Social"
payload.description = "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover."
payload.is_active = true
payload.name = "Tax-Efficient SRI Core 2"
payload.volatility = 0.0859
payload.performance = 0.0572
payload.node_map = [{node_id => "5aafb611-bae9-481c-9da0-03044af09a7a"},
    {node_id => "360baaa9-be8b-4463-bdae-974775cd894f"},
    {node_id => "b530b536-4f99-45d3-bdbc-4729992868dc"}]

begin
  #Create an allocation
  result = api_instance.post_allocation(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AllocationPayload payload = new AllocationPayload(category="Social",
    description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
    isActive=true,
    name="Tax-Efficient SRI Core 2",
    volatility = 0.0859,
    performance = 0.0572,
    nodeMap=["5aafb611-bae9-481c-9da0-03044af09a7a",
             "360baaa9-be8b-4463-bdae-974775cd894f",
             "b530b536-4f99-45d3-bdbc-4729992868dc"]);
try {
    CreateAllocationResponse result = apiInstance.postAllocation(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AllocationPayload(category="Social",
   description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
   isActive=true,
   name="Tax-Efficient SRI Core 2",
   volatility = 0.0859,
   performance = 0.0572,
   nodeMap=["5aafb611-bae9-481c-9da0-03044af09a7a",
            "360baaa9-be8b-4463-bdae-974775cd894f",
            "b530b536-4f99-45d3-bdbc-4729992868dc"]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAllocation(payload, callback);

Example Response

{
    "id": "013380bf-7f17-44c1-93c5-892a7ed3498c",
    "create_date": "2017-02-14T00:00:00.000+0000",
    "category": "Social",
    "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
    "is_active": true,
    "name": "Tax-Efficient SRI Core 2",
    "volatility": 0.0859,
    "performance": 0.0572,
    "node_map": [
        {
            "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
        },
        {
            "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
        },
        {
            "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
        }
    ],
    "metadata": {}
}

Create a new allocation for your firm. The endpoint returns the allocation_id used to manage the allocation and to map an account to the allocation.

HTTP REQUEST

POST /allocation

ARGUMENTS

Parameter Type Required Description
name string required Name of the allocation
category string optional Category for the allocation used to group similar allocations
description string optional Description of the allocation
client_id UUID optional If the allocation is to be used by a specific client such as an advisor, the id of the client
benchmark_id UUID optional The id for the benchmark that the allocation should be compared to
inception_date date optional Date that the allocation first was managed
node_map array optional List of nodes in a decision tree that map to the allocation
      node_id UUID required The id of the last node in the branch of a decision tree that maps to the allocation
metadata map optional Custom information associated with the allocation in the format key:value. See Metadata
is_active boolean optional Indicator if this allocation is active. Default is true which indicates it is active
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

PROTON API ARGUMENTS

The following fields may be optionally used in conjunction with the Proton API.

Field Type Required Description
performance double optional Historical performance for the allocation, used as an input for simulations.
volatility double optional Historical volatility for the allocation, used as an input for simulations.

Retrieve an allocation

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation/013380bf-7f17-44c1-93c5-892a7ed3498c"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'

try:
    # Retrieve an allocation
    api_response = api_instance.get_allocation(allocation_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'

begin
  #Retrieve an allocation
  result = api_instance.get_allocation(allocation_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("013380bf-7f17-44c1-93c5-892a7ed3498c");
try {
    SpecificAllocationResponse result = apiInstance.getAllocation(allocationId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "013380bf-7f17-44c1-93c5-892a7ed3498c";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocation(allocationId, callback);

Example Response

{
    "id": "013380bf-7f17-44c1-93c5-892a7ed3498c",
    "create_date": "2017-02-14T00:00:00.000+0000",
    "update_date": "2017-02-15T09:00:00.000+0000",
    "category": "Social",
    "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
    "is_active": true,
    "name": "Tax-Efficient SRI Core 2",
    "volatility": 0.0859,
    "performance": 0.0572,
    "node_map": [
        {
            "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
        },
        {
            "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
        },
        {
            "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
        }
    ],
    "metadata": {}
}

Retrieve the information for an allocation defined by your firm. The allocation_id must be provided. The endpoint returns the allocation_id and the details for the allocation specified.

HTTP REQUEST

GET /allocation/{allocation_id}

Update an allocation

HTTP REQUEST

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    -d '{
            "category": "Social",
            "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
            "is_active": true,
            "name": "Tax-Efficient SRI Core 2",
            "volatility": 0.0859,
            "performance": 0.0572,
            "node_map": [
                {
                    "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
                },
                {
                    "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
                },
                {
                    "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
                }
            ],
            "metadata": {}
        }' "https://api.hydrogenplatform.com/nucleus/v1/allocation/013380bf-7f17-44c1-93c5-892a7ed3498c"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'
payload = atom_api.AllocationPayload(category="Social",
     description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
     is_active=True,
     name="Tax-Efficient SRI Core 2",
     volatility=0.0859,
     performance=0.0572,
     node_map=[
                {
                    "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
                },
                {
                    "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
                },
                {
                    "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
                }
              ])

try:
    # Update an allocation
    api_response = api_instance.update_allocation(allocation_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'

payload = AtomApi::AllocationPayload.new
payload.category = "Social"
payload.description = "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover."
payload.is_active = true
payload.name = "Tax-Efficient SRI Core 2"
payload.volatility = 0.0859
payload.performance = 0.0572
payload.node_map = [{node_id => "5aafb611-bae9-481c-9da0-03044af09a7a"},
    {node_id => "360baaa9-be8b-4463-bdae-974775cd894f"},
    {node_id => "b530b536-4f99-45d3-bdbc-4729992868dc"}]

begin
  #Update an allocation
  result = api_instance.update_allocation(allocation_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("013380bf-7f17-44c1-93c5-892a7ed3498c");
AllocationPayload payload = new AllocationPayload(category="Social",
    description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
    isActive=true,
    name="Tax-Efficient SRI Core 2",
    volatility=0.0859,
    performance=0.0572,
    node_map=["5aafb611-bae9-481c-9da0-03044af09a7a",
              "360baaa9-be8b-4463-bdae-974775cd894f",
              "b530b536-4f99-45d3-bdbc-4729992868dc"]);
try {
    SpecificAllocationResponse result = apiInstance.updateAllocation(allocationId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "013380bf-7f17-44c1-93c5-892a7ed3498c";

var payload = new atom_api.AllocationPayload(category="Social",
   description="Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
   isActive=true,
   name="Tax-Efficient SRI Core 2",
   volatility=0.0859,
   performance=0.0572,
   node_map=["5aafb611-bae9-481c-9da0-03044af09a7a",
             "360baaa9-be8b-4463-bdae-974775cd894f",
             "b530b536-4f99-45d3-bdbc-4729992868dc"]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAllocation(allocationIdpayload, callback);

Example Response

{
    "id": "013380bf-7f17-44c1-93c5-892a7ed3498c",
    "create_date": "2017-02-14T00:00:00.000+0000",
    "update_date": "2017-02-15T09:00:00.000+0000",
    "category": "Social",
    "description": "Dynamically managed diversified socially responsible ETF strategy allocated to U.S. Equities and tax-exempt Fixed Income. The strategy is tailored to investors with a very low risk tolerance, and aims to preserve capital with low turnover.",
    "is_active": true,
    "name": "Tax-Efficient SRI Core 2",
    "volatility": 0.0859,
    "performance": 0.0572,
    "node_map": [
        {
            "node_id": "5aafb611-bae9-481c-9da0-03044af09a7a"
        },
        {
            "node_id": "360baaa9-be8b-4463-bdae-974775cd894f"
        },
        {
            "node_id": "b530b536-4f99-45d3-bdbc-4729992868dc"
        }
    ],
    "metadata": {}
}

Update an allocation defined by your firm. The allocation_id must be provided. To obtain the appropriate allocation_id, use the GET /allocation endpoint to view all of the allocations defined by your firm and their current information. The details to be updated must also be provided. The endpoint returns the allocation_id and the details for the allocation. If you wish to have an allocation no longer be available without permanently deleting it, use this endpoint to mark the is_active field as false.

PUT /allocation/{allocation_id}

Delete an allocation

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation/013380bf-7f17-44c1-93c5-892a7ed3498c"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'

try:
    # Delete an allocation
    api_instance.delete_allocation(allocation_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_allocation: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '013380bf-7f17-44c1-93c5-892a7ed3498c'

begin
  #Delete an allocation
  api_instance.delete_allocation(allocation_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_allocation: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("013380bf-7f17-44c1-93c5-892a7ed3498c");
try {
    apiInstance.deleteAllocation(allocationId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAllocation");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "013380bf-7f17-44c1-93c5-892a7ed3498c";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAllocation(allocationId, callback);

Response (204 No Content)

Permanently delete an allocation defined by your firm. The allocation_id must be provided. To obtain the appropriate allocation_id, use the GET /allocation endpoint to view all of the allocations defined by your firm. This deletes the allocation_id and the allocation record. If you wish to have an allocation no longer be available without permanently deleting it, use the PUT /allocation/{allocation_id} endpoint to mark the is_active field as false.

HTTP REQUEST

DELETE /allocation/{allocation_id}

Allocation Composition

Allocation Composition is used to assign models to an allocation with specific weights and track the composition over time.

Field Type Description
id UUID The id of the allocation composition record
allocation_id UUID The id of the allocation for which you are adding a composition record
model_id UUID The id of the model that is assigned to the allocation
current_weight double The current weight of the model as a percentage of the allocation’s total value; ex. 20 representing 20%. The current weights of all the models must add up to 100. If the model is the only one, enter 100
strategic_weight double The strategic weight of the model as a percentage of the allocation’s total value; ex. 20 representing 20%. The strategic weights of all the models must add up to 100. If the model is the only one, enter 100
date date The date for this allocation composition record
metadata map Custom information associated with the entity in the format key:value
See Metadata

PROTON API

The following fields may be optionally used in conjunction with the Proton API.

Field Type Description
core boolean Indicator if the model_id is a core model for core-satellite investing. Defaults to false which means it is not a core model

List all allocation compositions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation_composition"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all allocation compositions
    api_response = api_instance.get_allocation_compositions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation_compositions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all allocation compositions
  result = api_instance.get_allocation_compositions()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation_compositions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetAllocationCompositionResponse result = apiInstance.getAllocationCompositions();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocationCompositions");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocationCompositions(opts, callback);

Example Response

{
    "content": [
        {
            "id": "2b74355b-00eb-460b-a504-822248e50621",
            "create_date": "2018-04-10T20:43:25.000+0000",
            "update_date": "2018-04-10T20:43:25.000+0000",
            "core": false,
            "current_weight": 100,
            "date": "2018-04-10",
            "strategic_weight": 100,
            "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
            "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc",
            "metadata": {}
        },
        {
            "id": "d05b26cc-367d-4c90-9365-cd89af237bbf",
            "create_date": "2018-04-05T20:42:19.000+0000",
            "update_date": "2018-04-05T20:42:19.000+0000",
            "core": false,
            "current_weight": 100,
            "date": "2018-04-05",
            "strategic_weight": 100,
            "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
            "allocation_id": "30708526-cf56-4560-8bd9-19e00417ec4b",
            "metadata": {}
        },
        {
            "id": "48745b11-ae08-4f96-8889-0be02a96bb5e",
            "create_date": "2018-04-05T20:32:25.000+0000",
            "update_date": "2018-04-05T20:32:25.000+0000",
            "core": false,
            "current_weight": 100,
            "date": "2018-04-05",
            "strategic_weight": 100,
            "model_id": "39c40045-df4b-4ebb-8df8-257dfe48c254",
            "allocation_id": "a31fc863-2a9a-48de-86f2-eb376370a64e",
            "metadata": {}
        }
    ],
    "last": false,
    "total_pages": 1,
    "total_elements": 3,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "first": true,
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get the allocation composition for all allocations. To view the composition of a specific allocation only, you may filter by the allocation_id.

HTTP REQUEST

GET /allocation_composition

Create an allocation composition

Example Request

curl -X POST -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    -d '{
            "core": false,
            "current_weight": 100,
            "date": "2018-04-10",
            "strategic_weight": 100,
            "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
            "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc"
        }' "https://api.hydrogenplatform.com/nucleus/v1/allocation_composition"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.AllocationCompositionPayload(core=False,
    current_weight=100,
    _date="2018-04-10",
    strategic_weight=100,
    model_id="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocation_id="9d076a5b-c9eb-4637-ab56-296165be3edc")

try:
    # Create an allocation composition
    api_response = api_instance.post_allocation_composition(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_allocation_composition: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::AllocationCompositionPayload.new
payload.core = false
payload.current_weight = 100
payload.date = "2018-04-10"
payload.strategic_weight = 100
payload.model_id = "dbebf51f-d325-4cdd-b043-78958e29bdce"
payload.allocation_id = "9d076a5b-c9eb-4637-ab56-296165be3edc"

begin
  #Create an allocation composition
  result = api_instance.post_allocation_composition(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_allocation_composition: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
AllocationCompositionPayload payload = new AllocationCompositionPayload(core=false,
    currentWeight=100,
    date="2018-04-10",
    strategicWeight=100,
    modelId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocationId="9d076a5b-c9eb-4637-ab56-296165be3edc");
try {
    CreateAllocationCompositionResponse result = apiInstance.postAllocationComposition(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postAllocationComposition");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.AllocationCompositionPayload(core=false,
    currentWeight=100,
    date="2018-04-10",
    strategicWeight=100,
    modelId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocationId="9d076a5b-c9eb-4637-ab56-296165be3edc");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postAllocationComposition(payload, callback);

Example Response

{
    "id": "2b74355b-00eb-460b-a504-822248e50621",
    "create_date": "2018-04-10T20:43:25.000+0000",
    "core": false,
    "current_weight": 100,
    "date": "2018-04-10",
    "strategic_weight": 100,
    "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
    "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc",
    "metadata": {}
}

Create a new allocation composition record for an allocation. An allocation will be composed of models and weights which you can store over time. The endpoint returns the allocation_composition_id used to manage the allocation composition record.

HTTP REQUEST

POST /allocation_composition

ARGUMENTS

Parameter Type Required Description
allocation_id UUID required The id of the allocation for which you are adding a composition record
model_id UUID required The id of the model that is assigned to the allocation
current_weight double required The current weight of the model as a percentage of the allocation’s total value; ex. 20 representing 20%. The current weights of all the models must add up to 100. If the model is the only one, enter 100
strategic_weight double required The strategic weight of the model as a percentage of the allocation’s total value; ex. 20 representing 20%. The strategic weights of all the models must add up to 100. If the model is the only one, enter 100
date date required The date for this allocation composition record
metadata map optional Custom information associated with the entity in the format key:value
See Metadata

PROTON API ARGUMENTS

The following fields may be optionally used in conjunction with the Proton API.

Parameter Type Required Description
core boolean optional Indicator if the model_id is a core model for core-satellite investing. Defaults to false which means it is not a core model

Retrieve an allocation composition

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation_composition/2b74355b-00eb-460b-a504-822248e50621"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'

try:
    # Retrieve an allocation composition
    api_response = api_instance.get_allocation_composition(allocation_composition_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation_composition: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'

begin
  #Retrieve an allocation composition
  result = api_instance.get_allocation_composition(allocation_composition_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation_composition: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationCompositionId = new UUID("2b74355b-00eb-460b-a504-822248e50621");
try {
    SpecificAllocationCompositionResponse result = apiInstance.getAllocationComposition(allocationCompositionId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocationComposition");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationCompositionId = "2b74355b-00eb-460b-a504-822248e50621";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocationComposition(allocationCompositionId, callback);

Example Response

{
    "id": "2b74355b-00eb-460b-a504-822248e50621",
    "create_date": "2018-04-10T20:43:25.000+0000",
    "update_date": "2018-04-10T20:43:25.000+0000",
    "core": false,
    "current_weight": 100,
    "date": "2018-04-10",
    "strategic_weight": 100,
    "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
    "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc",
    "metadata": {}
}

Retrieve the information of an allocation composition record for an allocation. The allocation_composition_id must be provided. To obtain the appropriate allocation_composition_id for an allocation, use the GET /allocation_composition endpoint and filter by the allocation_id.

HTTP REQUEST

GET /allocation_composition/{allocation_composition_id}

Update an allocation composition

Example Request

curl -X PUT -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    -d '{
            "core": false,
            "current_weight": 100,
            "date": "2018-04-10",
            "strategic_weight": 100,
            "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
            "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc"
        }' "https://api.hydrogenplatform.com/nucleus/v1/allocation_composition/2b74355b-00eb-460b-a504-822248e50621"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'
payload = atom_api.AllocationCompositionPayload(core=False,
    current_weight=100,
    _date="2018-04-10",
    strategic_weight=100,
    model_id="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocation_id="9d076a5b-c9eb-4637-ab56-296165be3edc")

try:
    # Update an allocation composition
    api_response = api_instance.update_allocation_composition(allocation_composition_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_allocation_composition: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'

payload = AtomApi::AllocationCompositionPayload.new
payload.core = false
payload.current_weight = 100
payload.date = "2018-04-10"
payload.strategic_weight = 100
payload.model_id = "dbebf51f-d325-4cdd-b043-78958e29bdce"
payload.allocation_id = "9d076a5b-c9eb-4637-ab56-296165be3edc"

begin
  #Update an allocation composition
  result = api_instance.update_allocation_composition(allocation_composition_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_allocation_composition: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationCompositionId = new UUID("2b74355b-00eb-460b-a504-822248e50621");
AllocationCompositionPayload payload = new AllocationCompositionPayload(core=false,
    currentWeight=100,
    date="2018-04-10",
    strategicWeight=100,
    modelId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocationId="9d076a5b-c9eb-4637-ab56-296165be3edc");
try {
    GetAllocationCompositionResponse result = apiInstance.updateAllocationComposition(allocationCompositionId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateAllocationComposition");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var allocationCompositionId = "2b74355b-00eb-460b-a504-822248e50621";

var payload = new atom_api.AllocationCompositionPayload(core=false,
    currentWeight=100,
    date="2018-04-10",
    strategicWeight=100,
    modelId="dbebf51f-d325-4cdd-b043-78958e29bdce",
    allocationId="9d076a5b-c9eb-4637-ab56-296165be3edc");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateAllocationComposition(allocationCompositionIdpayload, callback);

Example Response

{
    "id": "2b74355b-00eb-460b-a504-822248e50621",
    "create_date": "2018-04-10T20:43:25.000+0000",
    "update_date": "2018-04-10T20:43:25.000+0000",
    "core": false,
    "current_weight": 100,
    "date": "2018-04-10",
    "strategic_weight": 100,
    "model_id": "dbebf51f-d325-4cdd-b043-78958e29bdce",
    "allocation_id": "9d076a5b-c9eb-4637-ab56-296165be3edc",
    "metadata": {}
}

Update the information of an allocation composition record for an allocation. The allocation_composition_id must be provided. To obtain the appropriate allocation_composition_id for an allocation, use the GET /allocation_composition endpoint and filter by the allocation_id. The details to be updated must also be provided. The endpoint returns the allocation_composition_id and the details for the updated allocation composition record.

HTTP REQUEST

PUT /allocation_composition/{allocation_composition_id}

Delete an allocation composition

Example Request

curl -X DELETE -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation_composition/2b74355b-00eb-460b-a504-822248e50621"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'

try:
    # Delete an allocation composition
    api_instance.delete_allocation_composition(allocation_composition_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_allocation_composition: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_composition_id = '2b74355b-00eb-460b-a504-822248e50621'

begin
  #Delete an allocation composition
  api_instance.delete_allocation_composition(allocation_composition_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_allocation_composition: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationCompositionId = new UUID("2b74355b-00eb-460b-a504-822248e50621");
try {
    apiInstance.deleteAllocationComposition(allocationCompositionId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteAllocationComposition");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationCompositionId = "2b74355b-00eb-460b-a504-822248e50621";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteAllocationComposition(allocationCompositionId, callback);

Response (204 No Content)

Permanently delete an allocation composition record for an allocation. The allocation_composition_id must be provided. To obtain the appropriate allocation_composition_id, use the GET /allocation_composition endpoint to view all of the allocation composition records for all allocations. This deletes the allocation_composition_id and the allocation composition record from the allocation.

HTTP REQUEST

DELETE /allocation/{allocation_composition_id}

Allocation Activity

List all allocation asset sizes

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation/8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0/asset_size"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

try:
    # List all allocation asset sizes
    api_response = api_instance.get_allocation_asset_sizes(allocation_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation_asset_sizes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

begin
  #List all allocation asset sizes
  result = api_instance.get_allocation_asset_sizes(allocation_id, opts)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation_asset_sizes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0");
try {
    AllocationAssetSizeResponse result = apiInstance.getAllocationAssetSizes(allocationId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocationAssetSizes");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocationAssetSizes(allocationId, opts, callback);

Example Response

[
    {
        "date": "2016-01-04",
        "value": 1
    },
    {
        "date": "2016-01-05",
        "value": 1.1
    }
]

Get a list of asset sizes by date for a specific allocation. Asset size records are created at a model level, and aggregated to yield the allocation asset size(s). Allocation asset size represents the “growth of a dollar” rather than a monetary amount. The unique allocation_id must be provided. To obtain the appropriate allocation_id, use the GET /allocation endpoint to view all allocations defined for your firm. The endpoint returns a date, an amount value, and the value added since the last asset size date, usually via deposit. Additional parameters available to narrow down what is returned include date range, only obtaining the latest record, and sorting by different units of time (eg. annually, quarterly, monthly, daily).

HTTP REQUEST

GET /allocation/{allocation_id}/asset_size

ARGUMENTS

Parameter Type Required Description
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set
sort_type string optional Sort the asset sizes by D Daily, M Monthly, Q Quarterly, Y Yearly. Defaults to D Daily if not set. Must be capital letters
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set
is_current_weight boolean optional Retrieve allocation asset sizes using the current weight for aggregation. Defaults to true if not set

RESPONSE

Field Type Description
date date Date for this asset size record
value double “Growth of a dollar” within the allocation on the particular date

List all allocation holdings

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
     "https://api.hydrogenplatform.com/nucleus/v1/allocation/8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0/holding"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

try:
    # List all allocation holdings
    api_response = api_instance.get_allocation_holdings(allocation_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation_holdings: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

begin
  #List all allocation holdings
  result = api_instance.get_allocation_holdings(allocation_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation_holdings: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0");
try {
    AllocationHoldingsResponse result = apiInstance.getAllocationHoldings(allocationId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocationHoldings");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocationHoldings(allocationId, opts, callback);

Example Response

[
    {
        "current_weight": 15,
        "date": "2018-02-02",
        "strategic_weight": 15,
        "security_id": "b28ca897-6c2a-4e8f-b33f-d143a5e9a988"
    },
    {
        "current_weight": 35,
        "date": "2018-02-02",
        "strategic_weight": 35,
        "security_id": "a3098d24-33bb-4eb9-95dc-f7d091371d00"
    },
    {
        "current_weight": 2,
        "date": "2018-02-02",
        "strategic_weight": 2,
        "security_id": "dd561cf3-540a-4506-bdf9-52b7c86661f6"
    },
    {
        "current_weight": 6,
        "date": "2018-02-02",
        "strategic_weight": 6,
        "security_id": "f617534c-a2bb-49f6-a5c5-6ebcbaa3b274"
    },
    {
        "current_weight": 15,
        "date": "2018-02-02",
        "strategic_weight": 15,
        "security_id": "df82bd37-d390-41b9-9bef-6e599c58a316"
    },
    {
        "current_weight": 27,
        "date": "2018-02-02",
        "strategic_weight": 27,
        "security_id": "46521baf-6037-4595-bf20-66ae9f2703e7"
    }
]

Get the information for all securities assigned to a specific allocation. This represents the securities an allocation should hold, according to the models associated with said allocation. Respective security weights are listed as a percentage of each model’s total holdings. Holding records are created at a model level and aggregated to show the holdings of the allocation. The unique allocation_id must be provided. To obtain the appropriate allocation_id, use the GET /allocation endpoint to view all allocations defined for your firm. The endpoint returns a list of security_ids and the details for all holding records. Additional parameters available to narrow down what is returned include a date range.

HTTP REQUEST

GET /allocation/{allocation_id}/holding

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
security_id UUID The id for the security included in the holding record
current_weight double Current weight of the security as a percentage of the model’s total monetary value; ex. 20 representing 20%
strategic_weight double Strategic weight of the security as a percentage of the model’s total monetary value; ex. 20 representing 20%
date date Date of the holding record

List all allocation transactions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/allocation/8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0/transaction"
}
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

try:
    # List all allocation transactions
    api_response = api_instance.get_allocation_transactions(allocation_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_allocation_transactions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

allocation_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

begin
  #List all allocation transactions
  result = api_instance.get_allocation_transactions(allocation_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_allocation_transactions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID allocationId = new UUID("8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0");
try {
    AllocationTransactionResponse result = apiInstance.getAllocationTransactions(allocationId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getAllocationTransactions");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var allocationId = "8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getAllocationTransactions(allocationId, opts, callback);

Example Response

{
    "content": [
        {
            "id": "8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0",
            "create_date": "2018-01-25T04:30:25",
            "update_date": "2018-01-26T09:00:00",
            "shares": 150,
            "price": 23.45,
            "date": "2018-01-25",
            "model_id": "b663c459-4bda-4c57-82ea-09d41817fa",
            "security_id": "9c75e982-5554-4725-b23e-43ff53876df6",
            "transaction_code_id": "f5397b-7d22-433f-b01e-8202184a6386",
        }
    ],
    "total_pages": 1,
    "total_elements": 1,
    "last": true,
    "sort": [
      {
        "direction": "DESC",
        "property": "id",
        "ignore_case": false,
        "null_handling": "NATIVE",
        "descending": true,
        "ascending": false
      }
    ],
    "first": true,
    "number_of_elements": 1,
    "size": 25,
    "number": 0
  }

Get the information for all transactions made under an allocation to achieve the composition of the allocation. Transactions represent buy or sell orders for securities. Transaction records are created at a model level and all transactions for each model below the allocation are returned to show the allocation’s transaction activity. Must provide the unique allocation_id. To obtain the appropriate allocation_id, use the GET /allocation endpoint to view all allocations defined for your firm. The endpoint returns a list of transaction_ids and details for each transaction. See the Order section for more information. Additional parameters available to narrow down what is returned include a date range or using the current weight for aggregation.

HTTP REQUEST

GET /allocation/{allocation_id}/transaction

ARGUMENTS

Parameter Type Required Description
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
id UUID The id of the allocation transaction record
shares double Number of shares of the security purchased as part of the transaction
price double Security price at which the shares were purchased as part of the transaction
date date Date of the allocation transaction
model_id UUID The id of the model that the allocation transaction record falls under
security_id UUID The id of the security included in the allocation transaction
transaction_code_id integer The id referring to the transaction codes defined by your firm
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Benchmark

Benchmark Management

A benchmark is assigned a group of securities to act as an index for the performance of some aspect of the market, whether that be the market as a whole or a specific segment of the market. The benchmark essentially acts as a proxy for a client, account, allocation, model, or portfolio that would also hold a group of securities to approximate or measure their performance. A benchmark can also hold just one security to be used as a benchmark security and track its price growth. Benchmarks are required to us the Performance endpoints.

Field Type Description
id UUID The id of the benchmark
name string Name of the benchmark
composition array List of securities and their respective weights as a percentage of the benchmark’s total value
      weight double The weight of the security as a percentage of the benchmark’s total value; ex. 20 representing 20%. The weights of all the securities must add up to 100
      security_id string The id of the security in the benchmark
description string Description of the benchmark such as the market segment that it represents
client_id string The id of the client to which the benchmark belongs, if any
is_active boolean Indicates if the benchmark is active. Defaults to true which means it is active
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all benchmarks

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/benchmark"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all benchmarks
    api_response = api_instance.get_benchmarks()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_benchmarks: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all benchmarks
  result = api_instance.get_benchmarks()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_benchmarks: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetBenchmarkResponse result = apiInstance.getBenchmarks();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getBenchmarks");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getBenchmarks(opts, callback);

Example Response

{
    "content": [
        {
            "id": "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf",
            "create_date": "2018-03-27T11:45:08.000+0000",
            "update_date": "2018-03-27T11:45:08.000+0000",
            "description": "80% US Small Cap, 20% US Municipal bonds",
            "is_active": true,
            "name": "80/20 US Benchmark",
            "composition": [
                {
                    "weight": 80,
                    "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
                },
                {
                    "weight": 20,
                    "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
                }
            ]
        },
        {
            "id": "d2e19c41-9c57-4508-a5e8-6dff7f0ffe7d",
            "create_date": "2018-03-27T11:44:22.000+0000",
            "update_date": "2018-03-27T11:44:22.000+0000",
            "description": "60% US Small Cap, 40% US Municipal bonds",
            "is_active": true,
            "name": "60/40 US Benchmark",
            "composition": [
                {
                    "weight": 60,
                    "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
                },
                {
                    "weight": 40,
                    "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
                }
            ]
        }
    ],
    "total_pages": 1,
    "total_elements": 2,
    "last": true,
    "number_of_elements": 2,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "descending": true,
            "ascending": false
        }
    ],
    "size": 25,
    "number": 0
}

Get details for all benchmarks defined for your firm. Note that the composition information is stored as a nested object within the benchmark object.

HTTP REQUEST

GET /benchmark

Create a benchmark

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" -H \
     -d '{
        "description": "80% US Small Cap, 20% US Municipal bonds",
        "name": "80/20 US Benchmark",
        "composition": [
            {
                "weight": 80,
                "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
            },
            {
                "weight": 20,
                "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
            }
        ]
     }' "https://api.hydrogenplatform.com/nucleus/v1/benchmark"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

comp_one = atom_api.BenchmarkPayloadComposition(weight=80, security_id="00178f8e-2c0b-4e15-b725-74d53b9533ef")
comp_two = atom_api.BenchmarkPayloadComposition(weight=20, security_id="001067fd-a504-43b0-858c-2a43a26e91e9")

payload = atom_api.BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp_one, comp_two])

try:
    # Create a benchmark
    api_response = api_instance.post_benchmark(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_benchmark: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::BenchmarkPayload.new
payload.description = "80% US Small Cap, 20% US Municipal bonds"
payload.name = "80/20 US Benchmark"

composition_one = AtomApi::BenchmarkPayloadComposition.new
composition_one.weight = 80
composition_one.security_id = "00178f8e-2c0b-4e15-b725-74d53b9533ef"
composition_two = AtomApi::BenchmarkPayloadComposition.new
composition_two.weight = 20
composition_two.security_id = "001067fd-a504-43b0-858c-2a43a26e91e9"
payload.composition = [composition_one, composition_two]

begin
  #Create a benchmark
  result = api_instance.post_benchmark(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_benchmark: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
BenchmarkPayloadComposition comp1 = new BenchmarkPayloadComposition(weight=80, securityId="00178f8e-2c0b-4e15-b725-74d53b9533ef");
BenchmarkPayloadComposition comp2 = new BenchmarkPayloadComposition(weight=20, securityId="001067fd-a504-43b0-858c-2a43a26e91e9");
BenchmarkPayload payload = new BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp1, comp2]);
try {
    CreateBenchmarkResponse result = apiInstance.postBenchmark(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postBenchmark");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var comp1 = new BenchmarkPayloadComposition(weight=80, securityId="00178f8e-2c0b-4e15-b725-74d53b9533ef");
var comp2 = new BenchmarkPayloadComposition(weight=20, securityId="001067fd-a504-43b0-858c-2a43a26e91e9");
var payload = new atom_api.BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp1, comp2]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postBenchmark(payload, callback);

Example Response

{
    "id": "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf",
    "create_date": "2018-03-27T11:45:08.000+0000",
    "description": "80% US Small Cap, 20% US Municipal bonds",
    "is_active": true,
    "name": "80/20 US Benchmark",
    "composition": [
        {
            "weight": 80,
            "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
        },
        {
            "weight": 20,
            "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
        }
    ]
}

Create a new benchmark for your firm. The name for the benchmark must be provided. The composition of securities and their weights should also be provided as a nested object for the benchmark to be usable. The create_date will default to the current date. The endpoint returns a benchmark_id used to manage the benchmark and assign it to allocations.

HTTP REQUEST

POST /benchmark

ARGUMENTS

Parameter Type Required Description
name string required Name of the benchmark
composition array optional List of securities and their respective weights as a percentage of the benchmark’s total value. It is recommended to provide at least one security_id
      weight double required The weight of the security as a percentage of the benchmark’s total value; ex. 20 representing 20%. The weights of all the securities must add up to 100
      security_id string required The id of the security in the benchmark
description string optional Description of the benchmark such as the market segment that it represents
client_id string optional The id of the client to which the benchmark belongs, if any
is_active boolean optional Indicates if the benchmark is active. Defaults to true which means it is active
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a benchmark

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/benchmark/d79bb3a3-f259-430c-8fa8-a93f87cc3bdf"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

try:
    # Retrieve a benchmark
    api_response = api_instance.get_benchmark(benchmark_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_benchmark: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

begin
  #Retrieve a benchmark
  result = api_instance.get_benchmark(benchmark_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_benchmark: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID benchmarkId = new UUID("d79bb3a3-f259-430c-8fa8-a93f87cc3bdf");
try {
    SpecificBenchmarkResponse result = apiInstance.getBenchmark(benchmarkId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getBenchmark");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var benchmarkId = "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getBenchmark(benchmarkId, , callback);

Example Response

{
    "id": "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf",
    "create_date": "2018-03-27T11:45:08.000+0000",
    "update_date": "2018-03-27T11:45:08.000+0000",
    "description": "80% US Small Cap, 20% US Municipal bonds",
    "is_active": true,
    "name": "80/20 US Benchmark",
    "composition": [
        {
            "weight": 80,
            "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
        },
        {
            "weight": 20,
            "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
        }
    ]
}

Retrieve the information for a benchmark. The benchmark_id must be provided. The endpoint returns the benchmark_id and the details for the benchmark specified.

HTTP REQUEST

GET /benchmark/{benchmark_id}

Update a benchmark

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" -H \
     -d '{
            "description": "80% US Small Cap, 20% US Municipal bonds",
             "name": "80/20 US Benchmark",
             "composition": [
                 {
                         "weight": 80,
                         "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
                 },
                 {
                         "weight": 20,
                         "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
                 }
             ]
        }' "https://api.hydrogenplatform.com/nucleus/v1/benchmark/d79bb3a3-f259-430c-8fa8-a93f87cc3bdf"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'
comp_one = atom_api.BenchmarkPayloadComposition(weight=80, security_id="00178f8e-2c0b-4e15-b725-74d53b9533ef")
comp_two = atom_api.BenchmarkPayloadComposition(weight=20, security_id="001067fd-a504-43b0-858c-2a43a26e91e9")
payload = atom_api.BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp_one, comp_two])

try:
    # Update a benchmark
    api_response = api_instance.update_benchmark(benchmark_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_benchmark: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

payload = AtomApi::BenchmarkPayload.new
payload.description = "80% US Small Cap, 20% US Municipal bonds"
payload.name = "80/20 US Benchmark"

composition_one = AtomApi::BenchmarkPayloadComposition.new
composition_one.weight = 80
composition_one.security_id = "00178f8e-2c0b-4e15-b725-74d53b9533ef"
composition_two = AtomApi::BenchmarkPayloadComposition.new
composition_two.weight = 20
composition_two.security_id = "001067fd-a504-43b0-858c-2a43a26e91e9"
payload.composition = [composition_one, composition_two]

begin
  #Update a benchmark
  result = api_instance.update_benchmark(benchmark_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_benchmark: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID benchmarkId = new UUID("d79bb3a3-f259-430c-8fa8-a93f87cc3bdf");
BenchmarkPayloadComposition comp1 = new BenchmarkPayloadComposition(weight=80, securityId="00178f8e-2c0b-4e15-b725-74d53b9533ef");
BenchmarkPayloadComposition comp2 = new BenchmarkPayloadComposition(weight=20, securityId="001067fd-a504-43b0-858c-2a43a26e91e9");
BenchmarkPayload payload = new BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp1, comp2]);
try {
    SpecificBenchmarkResponse result = apiInstance.updateBenchmark(benchmarkId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateBenchmark");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var benchmarkId = "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf";

var comp1 = new BenchmarkPayloadComposition(weight=80, securityId="00178f8e-2c0b-4e15-b725-74d53b9533ef");
var comp2 = new BenchmarkPayloadComposition(weight=20, securityId="001067fd-a504-43b0-858c-2a43a26e91e9");
var payload = new atom_api.BenchmarkPayload(description="80% US Small Cap, 20% US Municipal bonds",
    name="80/20 US Benchmark",
    composition=[comp1, comp2]);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateBenchmark(benchmarkId, payload, callback);

Example Response

{
    "id": "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf",
    "create_date": "2018-03-27T11:45:08.000+0000",
    "update_date": "2018-03-27T11:45:08.000+0000",
    "description": "80% US Small Cap, 20% US Municipal bonds",
    "is_active": true,
    "name": "80/20 US Benchmark",
    "composition": [
        {
            "weight": 80,
            "security_id": "00178f8e-2c0b-4e15-b725-74d53b9533ef"
        },
        {
            "weight": 20,
            "security_id": "001067fd-a504-43b0-858c-2a43a26e91e9"
        }
    ]
}

Updated the information for a benchmark. The benchmark_id must be provided. To obtain the appropriate benchmark_id, use the GET /benchmark endpoint to view all of the benchmarks defined firm-wide and their current information. The details to be updated and the details to be maintained must also be provided. The endpoint returns the benchmark_id and the details for the benchmark. To mark the benchmark as inactive so that it is no longer used without deleting it, you can use this endpoint to change the is_active field to false.

HTTP REQUEST

PUT /benchmark/{benchmark_id}

Delete a benchmark

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/benchmark/d79bb3a3-f259-430c-8fa8-a93f87cc3bdf"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

try:
    # Delete a benchmark
    api_instance.delete_benchmark(benchmark_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_benchmark: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

begin
  #Delete a benchmark
  api_instance.delete_benchmark(benchmark_id, )
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_benchmark: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID benchmarkId = new UUID("d79bb3a3-f259-430c-8fa8-a93f87cc3bdf");
try {
    apiInstance.deleteBenchmark(benchmarkId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteBenchmark");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var benchmarkId = "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteBenchmark(benchmarkId, , callback);

Response (204 No Content)

Permanently delete a benchmark. The benchmark_id must be provided. To obtain the appropriate benchmark_id, use the GET /benchmark endpoint to view all of the benchmarks defined firm-wide. This deletes the benchmark_id and the benchmark record. To mark the benchmark as inactive so that it is no longer used without deleting it, you can use the PUT /benchmark endpoint to change the is_active field to false.

HTTP REQUEST

DELETE /benchmark/{benchmark_id}

Benchmark Activity

List all benchmark asset sizes

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/benchmark/d79bb3a3-f259-430c-8fa8-a93f87cc3bdf/asset_size"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

try:
    # List all benchmark asset sizes
    api_response = api_instance.get_benchmark_asset_sizes(benchmark_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_benchmark_asset_sizes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

benchmark_id = 'd79bb3a3-f259-430c-8fa8-a93f87cc3bdf'

begin
  #List all benchmark asset sizes
  result = api_instance.get_benchmark_asset_sizes(benchmark_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_benchmark_asset_sizes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID benchmarkId = new UUID("d79bb3a3-f259-430c-8fa8-a93f87cc3bdf");
try {
    BenchmarkAssetSizeResponse result = apiInstance.getBenchmarkAssetSizes(benchmarkId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getBenchmarkAssetSizes");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var benchmarkId = "d79bb3a3-f259-430c-8fa8-a93f87cc3bdf";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getBenchmarkAssetSizes(benchmarkId, , opts, callback);

Example Response

[
    {
        "date": "2018-02-03",
        "value": 100.1,
    },
        {
        "date": "2018-02-04",
        "value": 100.2,
    },
        {
        "date": "2018-02-05",
        "value": 100.3,
    }
]

Get a list of asset sizes by date for a benchmark. Asset size records are calculated using the securities and their weights in the composition of the particular benchmark_id and the security prices. Benchmark asset size represents the “growth of a dollar” rather than a monetary amount. The unique benchmark_id must be provided. To obtain the appropriate benchmark_id, use the GET /benchmark endpoint to view the benchmarks defined for your firm. The endpoint returns a list of asset sizes by date for the benchmark. Additional parameters available to narrow down what is returned include date range, only obtaining the latest record, and sorting by different units of time (eg. annually, quarterly, monthly, daily).

HTTP REQUEST

GET /benchmark/{benchmark_id}/asset_size

ARGUMENTS

Parameter Type Required Description
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set
sort_type string optional Sort the asset sizes by D Daily, M Monthly, Q Quarterly, Y Yearly. Defaults to D Daily if not set. Must be capital letters
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
date date Date for this asset size record
value double “Growth of a dollar” within the benchmark on the particular date

Funding

Funding Requests

Funding records represent requests to move money to/from a client’s account. All deposits, withdrawals, and transfers to/from the account will always be connected to a funding request.

Field Type Description
id UUID The id for the specific funding request
amount double Amount that is included in the funding request
account_id UUID The id for the account that will be receiving the funding request
description string Description for the request, such as “Initial Funding”
bank_link_id UUID In the case that the funding request relates to a specific bank link, the id of the bank link providing the funds for the funding request
transfer_id UUID In the case that the funding request relates to the transfer of an external account into the account, the id of the transfer
support_ticket_id UUID In the case that the funding request is attached to a Support Ticket in the Electron API, the id of the ticket
funding_type string The type of the funding transaction. Value may be bank_transfer, wire_transfer, cash, debit_card, credit_card, check, stock_certificate, digital_wallet, money_order, account_transfer, or other
funding_status string Status of the funding request. Value may be request_received, request_initiated, request_declined, request_cancelled, or request_completed. In the case of a recurring request, the status remains request_received until the end date of the request
frequency_unit string Frequency of the funding request defined by your firm. Value may be one_time, daily, weekly, monthly, quarterly, or annually
frequency integer Number of frequency_unit between each request. For example, if the frequency_unit is weekly and the frequency is 2, this means the funding request occurs every two weeks. Default is 1
start_date date The date that the funding request should start
end_date date In the case that the funding request is recurring, the date that the funding request should stop occurring
last_request_date date The last date a recurring deposit or withdrawal was made to/from an account
next_request_date date The next date a recurring deposit or withdrawal is scheduled to/from an account
is_deposit boolean Indicator if the funding request is a deposit. true indicates it is a deposit, false a withdrawal
is_active boolean Indicates if the funding request is currently active. Defaults to true which indicates it is active
metadata map Custom information associated with the funding request in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all funding requests

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/funding"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all funding requests
    api_response = api_instance.get_funding_requests()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_funding_requests: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all funding requests
  result = api_instance.get_funding_requests()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_funding_requests: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetFundingRequestResponse result = apiInstance.getFundingRequests();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getFundingRequests");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getFundingRequests(opts, callback);

Example Response

{
    "content": [
    {
        "id": "708689ce-b0fd-4062-9954-6c8dd82707cf",
        "create_date": "2018-04-12T17:30:21.000+0000",
        "update_date": "2018-04-13T17:12:46.000+0000",
        "amount": 2000,
        "account_id": "04907eaa-3f33-49be-a35b-378cdf639fba",
        "description": "recurring funding",
        "frequency_unit": "one_time",
        "start_date": "2018-01-01",
        "end_date": "2019-01-01",
        "is_active": true,
        "is_deposit": true,
        "funding_type": "bank_transfer",
        "funding_status": "request_completed",
        "frequency": 2,
        "metadata": {}
    },
    {
        "id": "43a983e7-c930-443b-a499-53767814b07d",
        "create_date": "2018-03-19T16:06:47.000+0000",
        "update_date": "2018-03-19T16:06:47.000+0000",
        "amount": 2000,
        "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
        "frequency_unit": "monthly",
        "support_ticket_id": "bc2fee77-eb09-4a06-8680-2e2a2a3b0320",
        "start_date": "2018-01-01",
        "is_active": true,
        "is_deposit": true,
        "funding_type": "bank_transfer",
        "funding_status": "request_completed",
        "frequency": 2,
        "metadata": {}
    },
    {
        "id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
        "create_date": "2018-02-28T21:58:26.000+0000",
        "update_date": "2018-03-19T16:05:40.000+0000",
        "amount": 2000,
        "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
        "frequency_unit": "monthly",
        "start_date": "2018-01-01",
        "is_active": true,
        "is_deposit": true,
        "funding_type": "bank_transfer",
        "funding_status": "request_completed",
        "frequency": 2,
        "metadata": {}
    }
    ],
    "last": true,
    "total_elements": 3,
    "total_pages": 1,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": false,
            "descending": true
        }
    ],
    "number_of_elements": 3,
    "size": 25,
    "number": 0
}

Get the information for all funding requests defined for your firm. You can filter using an account_id to return the funding requests for a specific account. Note that the metadata information is stored as a nested object within the order record object.

HTTP REQUEST

GET /funding

Create a funding request

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    -H "Content-Type: application/json" \
    -d '{
              "amount": 2000,
              "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
              "frequency_unit": "monthly",
              "start_date": "2018-01-01",
              "is_active": true,
              "is_deposit": true,
              "funding_type": "bank_transfer",
              "funding_status": "request_completed",
              "frequency": 2
       }' "https://api.hydrogenplatform.com/nucleus/v1/funding"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.FundingRequestPayload(amount=2000,
     account_id="fbc03484-08e8-446d-83aa-6d6cc236355e",
     frequency_unit="monthly",
     start_date="2018-01-01",
     is_active=True,
     is_deposit=True,
     funding_type="bank_transfer",
     funding_status="request_completed",
     frequency=2)

try:
    # Create a funding request
    api_response = api_instance.post_funding_request(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_funding_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::FundingRequestPayload.new
payload.amount = 2000
payload.account_id = "fbc03484-08e8-446d-83aa-6d6cc236355e"
payload.frequency_unit = "monthly"
payload.start_date = "2018-01-01"
payload.is_active = true
payload.is_deposit = true
payload.funding_type = "bank_transfer"
payload.funding_status = "request_completed"
payload.frequency = 2

begin
  #Create a funding request
  result = api_instance.post_funding_request(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_funding_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
FundingRequestPayload payload = new FundingRequestPayload(amount=2000,
    accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
    frequencyUnit="monthly",
    startDate="2018-01-01",
    isActive=true,
    isDeposit=true,
    fundingType="bank_transfer",
    fundingStatus="request_completed",
    frequency=2);
try {
    CreateFundingRequestResponse result = apiInstance.postFundingRequest(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postFundingRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.FundingRequestPayload(amount=2000,
   accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
   frequencyUnit="monthly",
   startDate="2018-01-01",
   isActive=true,
   isDeposit=true,
   fundingType="bank_transfer",
   fundingStatus="request_completed",
   frequency=2);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postFundingRequest(payload, callback);

Example Response

{
    "id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    "create_date": "2018-02-28T21:58:26.000+0000",
    "amount": 2000,
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "frequency_unit": "monthly",
    "start_date": "2018-01-01",
    "is_active": true,
    "is_deposit": true,
    "funding_type": "bank_transfer",
    "funding_status": "request_completed",
    "frequency": 2,
    "metadata": {}
}

Create a new funding request for an account. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all the accounts defined for your firm. The create_date will default to the current date. The endpoint returns a funding_id used to manage the funding request. Note that the metadata information is stored as a nested object within the order record object.

HTTP REQUEST

POST /funding

ARGUMENTS

Parameter Type Required Description
account_id UUID required The id for the account that will be receiving the funding request
funding_type string required The type of the funding transaction. Value may be bank_transfer, wire_transfer, cash, debit_card, credit_card, check, stock_certificate, digital_wallet, money_order, account_transfer, or other
funding_status string required Status of the funding request. Value may be request_received, request_initiated, request_declined, request_cancelled, or request_completed. In the case of a recurring request, the status remains request_received until the end date of the request
frequency_unit string required Frequency of the funding request defined by your firm. Value may be one_time, daily, weekly, monthly, quarterly, or annually
is_deposit boolean required Indicates if the funding request is a deposit. true indicates it is a deposit, false a withdrawal
start_date date required The date that the funding request should start
end_date date optional In the case that the funding request is recurring, the date that the funding request should stop occurring
last_request_date date optional The last date a recurring deposit or withdrawal was made to/from an account
next_request_date date optional The next date a recurring deposit or withdrawal is scheduled to/from an account
frequency integer optional Number of frequency_unit between each request. For example, if the frequency_unit is weekly and the frequency is 2, this means the funding request occurs every two weeks. Default is 1
description string optional Description for the request, such as “Initial Funding”
amount double optional Amount that is included in the funding request
bank_link_id UUID optional In the case that the funding request relates to a specific bank link, the id of the bank link providing the funds for the funding request
transfer_id UUID optional In the case that the funding request relates to the transfer of an external account into the account, the id of the transfer
support_ticket_id UUID optional In the case that the funding request is attached to a Support Ticket in the Electron API, the id of the ticket
is_active boolean optional Indicates if the funding request is currently active. Defaults to true which indicates it is active.
metadata map optional Custom information associated with the funding request in the format key:value. See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a funding request

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/funding/9f5d3254-95c5-4c9d-8fad-f47c801bb888"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'

try:
    # Retrieve a funding request
    api_response = api_instance.get_funding_request(funding_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_funding_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'

begin
  #Retrieve a funding request
  result = api_instance.get_funding_request(funding_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_funding_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID fundingId = new UUID("9f5d3254-95c5-4c9d-8fad-f47c801bb888");
try {
    SpecificFundingRequestResponse result = apiInstance.getFundingRequest(fundingId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getFundingRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var fundingId = "9f5d3254-95c5-4c9d-8fad-f47c801bb888";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getFundingRequest(fundingId, callback);

Example Response

{
    "id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    "create_date": "2018-02-28T21:58:26.000+0000",
    "update_date": "2018-03-19T16:05:40.000+0000",
    "amount": 2000,
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "frequency_unit": "monthly",
    "start_date": "2018-01-01",
    "is_active": true,
    "is_deposit": true,
    "funding_type": "bank_transfer",
    "funding_status": "request_completed",
    "frequency": 2,
    "metadata": {}
}

Retrieve the information for a funding request for an account. The unique funding_id must be provided. The endpoint returns the details for the funding request specified.

HTTP REQUEST

GET /funding/{funding_id}

Update a funding request

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" \
     -d '{
            "amount": 2000,
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "frequency_unit": "monthly",
            "start_date": "2018-01-01",
            "is_active": true,
            "is_deposit": true,
            "funding_type": "bank_transfer",
            "funding_status": "request_completed",
            "frequency": 2
          }' "https://api.hydrogenplatform.com/nucleus/v1/funding/9f5d3254-95c5-4c9d-8fad-f47c801bb888"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'
payload = atom_api.FundingRequestPayload(amount=2000,
   account_id="fbc03484-08e8-446d-83aa-6d6cc236355e",
   frequency_unit="monthly",
   start_date="2018-01-01",
   is_active=True,
   is_deposit=True,
   funding_type="bank_transfer",
   funding_status="request_completed",
   frequency=2)

try:
    # Update a funding request
    api_response = api_instance.update_funding_request(funding_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_funding_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'

payload = AtomApi::FundingRequestPayload.new
payload.amount = 2000
payload.account_id = "fbc03484-08e8-446d-83aa-6d6cc236355e"
payload.frequency_unit = "monthly"
payload.start_date = "2018-01-01"
payload.is_active = true
payload.is_deposit = true
payload.funding_type = "bank_transfer"
payload.funding_status = "request_completed"
payload.frequency = 2

begin
  #Update a funding request
  result = api_instance.update_funding_request(funding_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_funding_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID fundingId = new UUID("9f5d3254-95c5-4c9d-8fad-f47c801bb888");
FundingRequestPayload payload = new FundingRequestPayload(amount=2000,
    accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
    frequencyUnit="monthly",
    startDate="2018-01-01",
    isActive=true,
    isDeposit=true,
    fundingType="bank_transfer",
    fundingStatus="request_completed",
    frequency=2);
try {
    SpecificFundingRequestResponse result = apiInstance.updateFundingRequest(fundingId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateFundingRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var fundingId = "9f5d3254-95c5-4c9d-8fad-f47c801bb888";

var payload = new atom_api.FundingRequestPayload(amount=2000,
   accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
   frequencyUnit="monthly",
   startDate="2018-01-01",
   isActive=true,
   isDeposit=true,
   fundingType="bank_transfer",
   fundingStatus="request_completed",
   frequency=2);

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateFundingRequest(fundingIdpayload, callback);

Example Response

{
    "id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    "create_date": "2018-02-28T21:58:26.000+0000",
    "update_date": "2018-03-19T16:05:40.000+0000",
    "amount": 2000,
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "frequency_unit": "monthly",
    "start_date": "2018-01-01",
    "is_active": true,
    "is_deposit": true,
    "funding_type": "bank_transfer",
    "funding_status": "request_completed",
    "frequency": 2,
    "metadata": {}
}

Update the information for a funding request for an account. The unique funding_id must be provided. To obtain the appropriate funding_id, use the GET /funding endpoint to view all funding requests defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the funding_id and all of the details for the funding request. If you wish to have the funding request no longer occur without permanently deleting it entirely, then use this endpoint to update the end_date field to the date when you wish the funding request to stop occurring. You can also use this endpoint to change the is_active field to false.

HTTP REQUEST

PUT /funding/{funding_id}

Delete a funding request

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/funding/9f5d3254-95c5-4c9d-8fad-f47c801bb888"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'

try:
    # Delete a funding request
    api_instance.delete_funding_request(funding_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_funding_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

funding_id = '9f5d3254-95c5-4c9d-8fad-f47c801bb888'

begin
  #Delete a funding request
  api_instance.delete_funding_request(funding_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_funding_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID fundingId = new UUID("9f5d3254-95c5-4c9d-8fad-f47c801bb888");
try {
    apiInstance.deleteFundingRequest(fundingId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteFundingRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var fundingId = "9f5d3254-95c5-4c9d-8fad-f47c801bb888";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteFundingRequest(fundingId, callback);

Response (204 No Content)

Permanently delete a funding request defined for an account. The unique funding_id must be provided. To obtain the appropriate funding_id, use the GET /funding endpoint to view all funding requests for your firm. Deletes the funding_id and the funding request record. If you wish to have the funding request no longer occur without permanently deleting it entirely, then use the PUT /funding/{funding_id} endpoint to update the end_date field to the date when you wish the funding request to stop occurring. You can also use the PUT /funding/{funding_id} endpoint to change the is_active field to false.

HTTP REQUEST

DELETE /funding/{funding_id}

Bank links are established connections between a client’s account on your platform and his or her bank account. They are used to transfer funds from the bank account to the account on your platform.

Field Type Description
id UUID The id for the specific bank link
bank_account_holder string Name of the individual that owns the bank account
bank_account_number string Account number of the bank account
name string Name of the bank for this bank link, e.g. HSBC
routing string Routing number of the bank for this bank link
routing_wire string Routing number of the bank for the bank link used for wire transfers
mask string The masked version of the bank account number for this bank link
bank_account_name string Name of the bank account, e.g. Mike’s HSBC Checking
client_id UUID The id for the client to which the bank link belongs
account_id UUID The id for the account to which the bank link belongs
currency_code string Alphabetic currency code for the base currency of the bank account linked, limited to 3 characters. See currency codes
balance string Current balance of the bank account
available_balance string Available balance of the bank account, usually taking into consideration pending transactions or available overdraft
type string Used to indicate the type of bank account for this bank link such as a ‘savings’ account
is_active boolean Indicates if the bank link is active. Defaults to true which indicates it is active
is_link_verified boolean Indicates if the bank link has been verified. Defaults to false which indicates it has not been verified
link_verified_date date Date and time that the bank link was verified
metadata map Custom information associated with the bank link in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created. Defaults to the current date
update_date timestamp Timestamp for the date and time that the record was last updated

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/bank_link"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all bank links
    api_response = api_instance.get_bank_links()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_bank_links: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all bank links
  result = api_instance.get_bank_links()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_bank_links: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetBankLinkResponse result = apiInstance.getBankLinks();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getBankLinks");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getBankLinks(opts, callback);

Example Response

{
  "content":
  [
    {
      "id": "4ff21db3-97ab-4bbd-9885-be6aec522c44",
      "create_date": "2018-04-12T17:34:17.000+0000",
      "update_date": "2018-04-12T17:34:17.000+0000",
      "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
      "bank_account_holder": "Jon Linndt",
      "bank_account_name": "HSBC Checking",
      "bank_account_number": "111111",
      "mask": "xx1111",
      "name": "HSBC",
      "routing": "111111",
      "routing_wire": "111111-22",
      "currency_code": "USD",
      "balance": "1500",
      "available_balance": "1600",
      "type": "Checking",
      "is_active": true,
      "is_link_verified": true,
      "link_verified_date": "2018-01-01",
      "type": "Checking",
      "metadata": {}
    },
    {
      "id": "425a2f77-b24b-4d93-ba13-a7b6bd01e947",
      "create_date": "2018-04-12T17:34:17.000+0000",
      "update_date": "2018-04-12T17:34:17.000+0000",
      "account_id": "272d9271-be64-4eb8-a3f4-abc57ca547c2",
      "bank_account_holder": "Andrew Williams",
      "bank_account_number": "2552001002",
      "mask": "xxxxxx1002",
      "bank_account_name": "Bank 2 - Checking Account",
      "name": "Bank XYZ2",
      "routing": "5289786002",
      "currency_code": "USD",
      "balance": "36754.04",
      "available_balance": "35754.04",
      "is_active": true,
      "is_link_verified": true,
      "link_verified_date": "2018-02-10",
      "metadata": {}
    },
    {
      "id": "d787cf19-d11c-49f2-abf3-f5fec1b101d4",
      "create_date": "2018-04-09T20:46:14.000+0000",
      "update_date": "2018-04-09T20:46:14.000+0000",
      "account_id": "199a8c08-cdd5-4c8c-8abf-535447cea11b",
      "bank_account_holder": "JB Smith",
      "bank_account_number": "2552001001",
      "mask": "xxxxxx1001",
      "bank_account_name": "Bank XYZ - Checking Account1",
      "name": "Bank XYZ",
      "routing": "5289786000",
      "routing_wire": "5289786011",
      "currency_code": "USD",
      "balance": "36760.00",
      "available_balance": "35760.00",
      "type": "Checking",
      "is_active": true,
      "is_link_verified": true,
      "link_verified_date": "2018-02-10",
      "metadata": {}
    }
  ],
    "total_elements": 3,
    "last": true,
    "total_pages": 1,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": false,
            "descending": true
        }
    ],
    "number_of_elements": 16,
    "size": 25,
    "number": 0
}

Get all bank links defined for all clients defined for your firm. The endpoint returns a list of UUIDs with details defined for each bank link. You can filter using an account_id to return the bank link(s) for a specific account.

HTTP REQUEST

GET /bank_link

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" \
     -d '{
              "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
              "bank_account_holder": "Jon Linndt",
              "bank_account_name": "HSBC Checking",
              "bank_account_number": "111111",
              "mask": "xx1111",
              "name": "HSBC",
              "routing": "111111",
              "routing_wire": "111111-22",
              "currency_code": "USD",
              "balance": "1500",
              "available_balance": "1600",
              "type": "Checking",
              "is_active": true,
              "is_link_verified": true,
              "link_verified_date": "2018-01-01"
          }' "https://api.hydrogenplatform.com/nucleus/v1/bank_link"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.BankLinkPayload(account_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
     bank_account_holder="Jon Linndt",
     bank_account_name="HSBC Checking",
     bank_account_number="111111",
     name="HSBC",
     routing="111111",
     routing_wire="111111-22",
     currency_code="USD",
     balance="1500",
     available_balance="1600",
     type="Checking",
     is_active=True,
     is_link_verified=True,
     link_verified_date="2018-01-01")

try:
    # Create a bank link
    api_response = api_instance.post_bank_link(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_bank_link: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::BankLinkPayload.new
payload.account_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
payload.bank_account_holder = "Jon Linndt"
payload.bank_account_name = "HSBC Checking"
payload.bank_account_number = "111111"
payload.name = "HSBC"
payload.routing = "111111"
payload.routing_wire = "111111-22"
payload.currency_code = "USD"
payload.balance = "1500"
payload.available_balance = "1600"
payload.type = "Checking"
payload.is_active = true
payload.is_link_verified = true
payload.link_verified_date = "2018-01-01"

begin
  #Create a bank link
  result = api_instance.post_bank_link(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_bank_link: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
BankLinkPayload payload = new BankLinkPayload(accountId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    bankAccountHolder="Jon Linndt",
    bankAccountName="HSBC Checking",
    bankAccountNumber="111111",
    name="HSBC",
    routing="111111",
    routingWire="111111-22",
    currencyCode="USD",
    balance="1500",
    availableBalance="1600",
    type="Checking",
    isActive=true,
    isLinkVerified=true,
    linkVerifiedDate="2018-01-01");
try {
    CreateBankLinkResponse result = apiInstance.postBankLink(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postBankLink");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.BankLinkPayload(accountId="647c54c3-b649-477e-8cc7-eee56a120dd3",
   bankAccountHolder="Jon Linndt",
   bankAccountName="HSBC Checking",
   bankAccountNumber="111111",
   name="HSBC",
   routing="111111",
   routingWire="111111-22",
   currencyCode="USD",
   balance="1500",
   availableBalance="1600",
   type="Checking",
   isActive=true,
   isLinkVerified=true,
   linkVerifiedDate="2018-01-01");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postBankLink(payload, callback);

Example Response

{
    "id": "4ff21db3-97ab-4bbd-9885-be6aec522c44",
    "create_date": "2018-04-12T17:34:17.000+0000",
    "update_date": "2018-04-12T17:34:17.000+0000",
    "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "bank_account_holder": "Jon Linndt",
    "bank_account_name": "HSBC Checking",
    "bank_account_number": "111111",
    "mask": "xx1111",
    "name": "HSBC",
    "routing": "111111",
    "routing_wire": "111111-22",
    "currency_code": "USD",
    "balance": "1500",
    "available_balance": "1600",
    "type": "Checking",
    "is_active": true,
    "is_link_verified": true,
    "link_verified_date": "2018-01-01",
    "metadata": {}
}

Create a new bank link for an account. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all the accounts defined for your firm. The create_date will default to the current date. The endpoint returns a bank_link_id used to manage the bank link going forward.

HTTP REQUEST

POST /bank_link

ARGUMENTS

Parameter Type Required Description
bank_account_holder string required Name of the individual that owns the bank account
bank_account_number string required Account number of the bank account
name string required Name of the bank for the bank link, e.g. HSBC
routing string required Routing number of the bank for the bank link
routing_wire string optional Routing number of the bank for the bank link used for wire transfers
mask string optional The masked version of the bank account number for this bank link
bank_account_name string optional Name of the bank account, e.g. Mike’s HSBC Checking
client_id UUID optional The id for the client to which the bank link belongs
account_id UUID optional The id for the account to which the bank link belongs
currency_code string optional Alphabetic currency code for the base currency of the bank account linked, limited to 3 characters. See currency codes
balance string optional Current balance of the bank account
available_balance string optional Available balance of the bank account, usually taking into consideration pending transactions or available overdraft
type string optional Used to indicate the type of bank account for this bank link such as a ‘savings’ account
is_active boolean optional Indicates if the bank link is active. Defaults to true which indicates it is active
is_link_verified boolean optional Indicates if the bank link has been verified. Defaults to false which indicates it has not been verified
link_verified_date date optional Date and time that the bank link was verified
metadata map optional Custom information associated with the bank link in the format key:value. See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/bank_link/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

try:
    # Retrieve a bank link
    api_response = api_instance.get_bank_link(bank_link_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_bank_link: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

begin
  #Retrieve a bank link
  result = api_instance.get_bank_link(bank_link_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_bank_link: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID bankLinkId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
try {
    SpecificBankLinkResponse result = apiInstance.getBankLink(bankLinkId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getBankLink");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var bankLinkId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getBankLink(bankLinkId, callback);

Example Response

{
    "id": "4ff21db3-97ab-4bbd-9885-be6aec522c44",
    "create_date": "2018-04-12T17:34:17.000+0000",
    "update_date": "2018-04-12T17:34:17.000+0000",
    "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "bank_account_holder": "Jon Linndt",
    "bank_account_name": "HSBC Checking",
    "bank_account_number": "111111",
    "mask": "xx1111",
    "name": "HSBC",
    "routing": "111111",
    "routing_wire": "111111-22",
    "currency_code": "USD",
    "balance": "1500",
    "available_balance": "1600",
    "type": "Checking",
    "is_active": true,
    "is_link_verified": true,
    "link_verified_date": "2018-01-01",
    "metadata": {}
}

Retrieve the information for a bank link for an account. The unique bank_link_id must be provided. The endpoint returns the details for the bank link specified.

HTTP REQUEST

GET /bank_link/{bank_link_id}

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" \
     -d '{
              "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
              "bank_account_holder": "Jon Linndt",
              "bank_account_name": "HSBC Checking",
              "bank_account_number": "111111",
              "mask": "xx1111",
              "name": "HSBC",
              "routing": "111111",
              "routing_wire": "111111-22",
              "currency_code": "USD",
              "balance": "1600",
              "available_balance": "1600",
              "type": "Checking",
              "is_active": true,
              "is_link_verified": true,
              "link_verified_date": "2018-01-01",
              "metadata": {}
        }' "https://api.hydrogenplatform.com/nucleus/v1/bank_link/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'
payload = atom_api.BankLinkPayload(account_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
   bank_account_holder="Jon Linndt",
   bank_account_name="HSBC Checking",
   bank_account_number="111111",
   name="HSBC",
   routing="111111",
   routing_wire="111111-22",
   currency_code="USD",
   balance="1600",
   available_balance="1600",
   type="Checking",
   is_active=True,
   is_link_verified=True,
   link_verified_date="2018-01-01")

try:
    # Update a bank link
    api_response = api_instance.update_bank_link(bank_link_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_bank_link: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

payload = AtomApi::BankLinkPayload.new
payload.account_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
payload.bank_account_holder = "Jon Linndt"
payload.bank_account_name = "HSBC Checking"
payload.bank_account_number = "111111"
payload.name = "HSBC"
payload.routing = "111111"
payload.routing_wire = "111111-22"
payload.currency_code = "USD"
payload.balance = "1600"
payload.available_balance = "1600"
payload.type = "Checking"
payload.is_active = true
payload.is_link_verified = true
payload.link_verified_date = "2018-01-01"

begin
  #Update a bank link
  result = api_instance.update_bank_link(bank_link_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_bank_link: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID bankLinkId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
BankLinkPayload payload = new BankLinkPayload(accountId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    bankAccountHolder="Jon Linndt",
    bankAccountName="HSBC Checking",
    bankAccountNumber="111111",
    name="HSBC",
    routing="111111",
    routingWire="111111-22",
    currencyCode="USD",
    balance="1600",
    availableBalance="1600",
    type="Checking",
    isActive=true,
    isLinkVerified=true,
    linkVerifiedDate="2018-01-01");
try {
    SpecificBankLinkResponse result = apiInstance.updateBankLink(bankLinkId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateBankLink");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var bankLinkId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var payload = new atom_api.BankLinkPayload(accountId="647c54c3-b649-477e-8cc7-eee56a120dd3",
   bankAccountHolder="Jon Linndt",
   bankAccountName="HSBC Checking",
   bankAccountNumber="111111",
   name="HSBC",
   routing="111111",
   routingWire="111111-22",
   currencyCode="USD",
   balance="1600",
   availableBalance="1600",
   type="Checking",
   isActive=true,
   isLinkVerified=true,
   linkVerifiedDate="2018-01-01");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateBankLink(bankLinkIdpayload, callback);

Example Response

{
    "id": "4ff21db3-97ab-4bbd-9885-be6aec522c44",
    "create_date": "2018-04-12T17:34:17.000+0000",
    "update_date": "2018-04-12T17:34:17.000+0000",
    "account_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "bank_account_holder": "Jon Linndt",
    "bank_account_name": "HSBC Checking",
    "bank_account_number": "111111",
    "mask": "xx1111",
    "name": "HSBC",
    "routing": "111111",
    "routing_wire": "111111-22",
    "currency_code": "USD",
    "balance": "1600",
    "available_balance": "1600",
    "type": "Checking",
    "is_active": true,
    "is_link_verified": true,
    "link_verified_date": "2018-01-01",
    "metadata": {}
}

Update the information for a bank link for an account. The unique bank_link_id must be provided. To obtain the appropriate bank_link_id, use the GET /bank_link endpoint to view all the bank links defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the bank_link_id and all of the details for the bank link. If you wish to have a bank link be no longer available for use without permanently deleting it entirely, then use this endpoint to update the is_active field to false.

HTTP REQUEST

PUT /bank_link/{bank_link_id}

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/bank_link/d787cf19-d11c-49f2-abf3-f5fec1b101d4"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

try:
    # Delete a bank link
    api_instance.delete_bank_link(bank_link_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_bank_link: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

bank_link_id = 'd787cf19-d11c-49f2-abf3-f5fec1b101d4'

begin
  #Delete a bank link
  api_instance.delete_bank_link(bank_link_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_bank_link: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID bankLinkId = new UUID("d787cf19-d11c-49f2-abf3-f5fec1b101d4");
try {
    apiInstance.deleteBankLink(bankLinkId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteBankLink");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var bankLinkId = "d787cf19-d11c-49f2-abf3-f5fec1b101d4";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteBankLink(bankLinkId, callback);

Response (204 No Content)

Permanently delete a bank link defined for an account. The unique bank_link_id must be provided. To obtain the appropriate bank_link_id, use the GET /bank_link endpoint to view all the bank links defined for your firm. This will delete the bank_link_id and the associated information so that the bank link can no longer be used. If you wish to have the bank link be no longer available for use without permanently deleting it entirely, then use the PUT /bank_link/{bank_link_id} endpoint to update the is_active field to mark the bank_link_id as inactive.

HTTP REQUEST

DELETE /bank_link/{bank_link_id}

Deposit

Deposits represent transactions to add funds to be invested into a client’s account. The transactions are often recurring to continue to increase the funds the client is investing.

Field Type Description
id UUID The id for the specific deposit request
account_id UUID The id for the account that is the destination of the deposit
amount double Amount that is being deposited
funding_id UUID The id of the funding record that maps to this deposit
invested_date timestamp Date and time that the funds should be pulled from the funding request to be invested
account_number string Bank account number that is the source of the deposit
comments string Comment for the deposit such as “Funded”
direction string Label to indicate the direction of the transaction such as “Incoming” or “Outgoing”
last_request_date timestamp In the case of recurring deposits, the last date and time that the deposit was last requested
received_date timestamp Date and time that the deposit was received into the account
status string Status of the deposit transaction such as “Processing”. Use this field to track the status of the individual deposit if it is associated with a recurring Funding request
status_time_stamp timestamp Date and time that the status of the record was last updated
type string Indicates the payment type such as “check, “wire”, etc.
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all deposit requests

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/deposit"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all deposit requests
    api_response = api_instance.get_deposit_requests()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_deposit_requests: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all deposit requests
  result = api_instance.get_deposit_requests()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_deposit_requests: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetDepositRequestResponse result = apiInstance.getDepositRequests();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getDepositRequests");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getDepositRequests(opts, callback);

Example Response

{
    "content": [
        {
            "id": "1a2bb85f-c1b4-41d5-9bf3-e23cce54b71c",
            "create_date": "2018-03-19T16:09:38.000+0000",
            "update_date": "2018-03-19T16:09:38.000+0000",
            "amount": 2000,
            "funding_id": "43a983e7-c930-443b-a499-53767814b07d",
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "comments" : "Add to 2018 IRA",
            "invested_date": "2018-04-02T09:00:00.000+0000",
            "last_request_date": "2018-04-01T09:00:00.000+0000",
            "received_date": "2018-03-01T17:00:00.000+0000",
            "metadata": {}
        },
        {
            "id": "c1df397e-17c0-4fab-a61f-367f7ff90f57",
            "create_date": "2018-03-19T15:16:50.000+0000",
            "update_date": "2018-03-19T16:08:59.000+0000",
            "amount": 2000,
            "funding_id": "43a983e7-c930-443b-a499-53767814b07d",
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "comments" : "Add to 2018 IRA",
            "invested_date": "2018-03-02T09:00:00.000+0000",
            "last_request_date": "2018-03-01T09:00:00.000+0000",
            "received_date": "2018-03-01T17:00:00.000+0000",
            "metadata": {}
        },
        {
            "id": "08e5f077-0c8c-4831-a4cc-3a7a59e067d2",
            "create_date": "2018-03-19T15:16:47.000+0000",
            "update_date": "2018-03-19T15:16:47.000+0000",
            "amount": 2000,
            "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "comments" : "Add to 2018 IRA",
            "invested_date": "2018-02-01T09:00:00.000+0000",
            "last_request_date": "2018-02-01T09:00:00.000+0000",
            "received_date": "2018-02-01T17:00:00.000+0000",
            "metadata": {}
        }
    ],
    "total_elements": 3,
    "last": true,
    "total_pages": 1,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": false,
            "descending": true
        }
    ],
    "number_of_elements": 4,
    "size": 25,
    "number": 0
}

Get the information for all deposit requests for all clients. The endpoint returns a list of UUIDs and details for each deposit request. You can filter using the account_id to view deposit requests for a specific account.

HTTP REQUEST

GET /deposit

Create a deposit request

Example Request

curl -X POST -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
            "amount": 2000,
            "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "comments" : "Add to 2018 IRA",
            "invested_date": "2018-02-01T09:00:00.000+0000",
            "last_request_date": "2018-02-01T09:00:00.000+0000",
            "received_date": "2018-02-01T17:00:00.000+0000"
        }' "https://api.hydrogenplatform.com/nucleus/v1/deposit"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.DepositRequestPayload(amount=2000,
   funding_id="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
   account_id="fbc03484-08e8-446d-83aa-6d6cc236355e",
   comments="Add to 2018 IRA",
   invested_date="2018-02-01T09:00:00.000+0000",
   last_request_date="2018-02-01T09:00:00.000+0000",
   received_date="2018-02-01T17:00:00.000+0000")

try:
    # Create a deposit request
    api_response = api_instance.post_deposit_request(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_deposit_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::DepositRequestPayload.new
payload.amount = 2000
payload.funding_id = "9f5d3254-95c5-4c9d-8fad-f47c801bb888"
payload.account_id = "fbc03484-08e8-446d-83aa-6d6cc236355e"
payload.comments = "Add to 2018 IRA"
payload.invested_date = "2018-02-01T09:00:00.000+0000"
payload.last_request_date = "2018-02-01T09:00:00.000+0000"
payload.received_date = "2018-02-01T17:00:00.000+0000"

begin
  #Create a deposit request
  result = api_instance.post_deposit_request(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_deposit_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
DepositRequestPayload payload = new DepositRequestPayload(amount=2000,
    fundingId="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
    comments="Add to 2018 IRA",
    investedDate="2018-02-01T09:00:00.000+0000",
    lastRequestDate="2018-02-01T09:00:00.000+0000",
    receivedDate="2018-02-01T17:00:00.000+0000");
try {
    CreateDepositRequestResponse result = apiInstance.postDepositRequest(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postDepositRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.DepositRequestPayload(amount=2000,
   fundingId="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
   accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
   comments="Add to 2018 IRA",
   investedDate="2018-02-01T09:00:00.000+0000",
   lastRequestDate="2018-02-01T09:00:00.000+0000",
   receivedDate="2018-02-01T17:00:00.000+0000");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postDepositRequest(payload, callback);

Example Response

{
    "id": "08e5f077-0c8c-4831-a4cc-3a7a59e067d2",
    "create_date": "2018-03-19T15:16:47.000+0000",
    "amount": 2000,
    "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "comments" : "Add to 2018 IRA",
    "invested_date": "2018-02-01T09:00:00.000+0000",
    "last_request_date": "2018-02-01T09:00:00.000+0000",
    "received_date": "2018-02-01T17:00:00.000+0000",
  "metadata": {}
}

Create a new deposit request for an account. The unique account_id for the deposit must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all the accounts defined for your firm. The create_date will default to the current date. The endpoint returns a unique deposit_id used to manage the deposit request.

HTTP REQUEST

POST /deposit

ARGUMENTS

Parameter Type Required Description
account_id UUID required The id for the account that is the destination of the deposit
amount double required Amount that is being deposited
funding_id UUID required The id of the funding record that maps to this deposit
invested_date timestamp required Date and time that the funds should be pulled from the funding request to be invested
account_number string optional Bank account number that is the source of the deposit
comments string optional Comment for the deposit such as “Funded”
direction string optional Label to indicate the direction of the transaction such as “Incoming” or “Outgoing”
last_request_date timestamp optional In the case of recurring deposits, the last date and time that the deposit was last requested
received_date timestamp optional Date and time that the deposit was received into the account
status string optional Status of the deposit transaction such as “Processing”. Use this field to track the status of the individual deposit if it is associated with a recurring Funding request
status_time_stamp timestamp optional Date and time that the record was last updated
type string optional Indicates the payment type such as “check, “wire”, etc.
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a deposit request

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/deposit/08e5f077-0c8c-4831-a4cc-3a7a59e067d2"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'

try:
    # Retrieve a deposit request
    api_response = api_instance.get_deposit_request(deposit_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_deposit_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'

begin
  #Retrieve a deposit request
  result = api_instance.get_deposit_request(deposit_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_deposit_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID depositId = new UUID("08e5f077-0c8c-4831-a4cc-3a7a59e067d2");
try {
    SpecificDepositRequestResponse result = apiInstance.getDepositRequest(depositId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getDepositRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var depositId = "08e5f077-0c8c-4831-a4cc-3a7a59e067d2";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getDepositRequest(depositId, callback);

Example Response

{
    "id": "08e5f077-0c8c-4831-a4cc-3a7a59e067d2",
    "create_date": "2018-03-19T15:16:47.000+0000",
    "update_date": "2018-03-19T15:16:47.000+0000",
    "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    "amount": 2000,
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "comments" : "Add to 2018 IRA",
    "invested_date": "2018-02-01T09:00:00.000+0000",
    "last_request_date": "2018-02-01T09:00:00.000+0000",
    "received_date": "2018-02-01T17:00:00.000+0000",
  "metadata": {}
}

Retrieve the information for a deposit request for an account. The unique deposit_id must be provided. The endpoint returns details for the deposit request specified.

HTTP REQUEST

GET /deposit/{deposit_id}

Update a deposit request

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
            "account_number": "569345",
            "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
            "amount": 2000,
            "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
            "comments" : "Add to 2018 IRA",
            "invested_date": "2018-02-01T09:00:00.000+0000",
            "last_request_date": "2018-02-01T09:00:00.000+0000",
            "received_date": "2018-02-01T17:00:00.000+0000"
    }' "https://api.hydrogenplatform.com/nucleus/v1/deposit/08e5f077-0c8c-4831-a4cc-3a7a59e067d2"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'
payload = atom_api.DepositRequestPayload(account_number="569345",
   funding_id="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
   amount=2000,
   account_id="fbc03484-08e8-446d-83aa-6d6cc236355e",
   comments="Add to 2018 IRA",
   invested_date="2018-02-01T09:00:00.000+0000",
   last_request_date="2018-02-01T09:00:00.000+0000",
   received_date="2018-02-01T17:00:00.000+0000")

try:
    # Update a deposit request
    api_response = api_instance.update_deposit_request(deposit_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_deposit_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'

payload = AtomApi::DepositRequestPayload.new
payload.account_number = "569345"
payload.funding_id = "9f5d3254-95c5-4c9d-8fad-f47c801bb888"
payload.amount = 2000
payload.account_id = "fbc03484-08e8-446d-83aa-6d6cc236355e"
payload.comments = "Add to 2018 IRA"
payload.invested_date = "2018-02-01T09:00:00.000+0000"
payload.last_request_date = "2018-02-01T09:00:00.000+0000"
payload.received_date = "2018-02-01T17:00:00.000+0000"

begin
  #Update a deposit request
  result = api_instance.update_deposit_request(deposit_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_deposit_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID depositId = new UUID("08e5f077-0c8c-4831-a4cc-3a7a59e067d2");
DepositRequestPayload payload = new DepositRequestPayload(accountNumber="569345",
    fundingId="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
    amount=2000,
    accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
    comments="Add to 2018 IRA",
    investedDate="2018-02-01T09:00:00.000+0000",
    lastRequestDate="2018-02-01T09:00:00.000+0000",
    receivedDate="2018-02-01T17:00:00.000+0000");
try {
    SpecificDepositRequestResponse result = apiInstance.updateDepositRequest(depositId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateDepositRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var depositId = "08e5f077-0c8c-4831-a4cc-3a7a59e067d2";

var payload = new atom_api.DepositRequestPayload(accountNumber="569345",
     fundingId="9f5d3254-95c5-4c9d-8fad-f47c801bb888",
     amount=2000,
     accountId="fbc03484-08e8-446d-83aa-6d6cc236355e",
     comments="Add to 2018 IRA",
     investedDate="2018-02-01T09:00:00.000+0000",
     lastRequestDate="2018-02-01T09:00:00.000+0000",
     receivedDate="2018-02-01T17:00:00.000+0000");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateDepositRequest(depositIdpayload, callback);

Example Response

{
    "id": "08e5f077-0c8c-4831-a4cc-3a7a59e067d2",
    "create_date": "2018-03-19T15:16:47.000+0000",
    "update_date": "2018-03-19T15:16:47.000+0000",
    "account_number": "569345",
    "funding_id": "9f5d3254-95c5-4c9d-8fad-f47c801bb888",
  "amount": 2000,
    "account_id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
    "comments" : "Add to 2018 IRA",
    "invested_date": "2018-02-01T09:00:00.000+0000",
    "last_request_date": "2018-02-01T09:00:00.000+0000",
    "received_date": "2018-02-01T17:00:00.000+0000",
  "metadata": {}
}

Update the information for a deposit request for an account. The unique deposit_id must be provided. To obtain the appropriate deposit_id, use the GET /deposit endpoint to view all the bank links defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the deposit_id and all of the details for the deposit request.

HTTP REQUEST

PUT /deposit/{deposit_id}

Delete a deposit request

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/deposit/08e5f077-0c8c-4831-a4cc-3a7a59e067d2"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'

try:
    # Delete a deposit request
    api_instance.delete_deposit_request(deposit_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_deposit_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

deposit_id = '08e5f077-0c8c-4831-a4cc-3a7a59e067d2'

begin
  #Delete a deposit request
  api_instance.delete_deposit_request(deposit_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_deposit_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID depositId = new UUID("08e5f077-0c8c-4831-a4cc-3a7a59e067d2");
try {
    apiInstance.deleteDepositRequest(depositId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteDepositRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var depositId = "08e5f077-0c8c-4831-a4cc-3a7a59e067d2";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteDepositRequest(depositId, callback);

Response (204 No Content)

Permanently delete a deposit request for an account. The unique deposit_id must be provided. To obtain the appropriate deposit_id, use the GET /deposit endpoint to view all deposit requests defined for your firm. This deletes the deposit_id and deposit request record.

HTTP REQUEST

DELETE /deposit/{deposit_id}

Withdrawal

Withdrawal requests represent transactions to remove funds from a client’s account, usually to deposit in another account on the platform or to transfer to an external account.

Field Type Description
id UUID The id for the specific withdrawal request
account_id UUID The id for the account that is the destination of the withdrawal
amount double Amount that is being withdrawn from the account
funding_id UUID The id of the funding record that maps to this withdrawal
withdrawal_date timestamp Date and time that the withdrawal was made
account_number string Bank account number that is the destination of the withdrawal
comments string Comment for the withdrawal such as “Funded”
direction string Label to indicate the direction of the transaction such as “Incoming” or “Outgoing”
fees string Any fees associated with the withdrawal, especially for an investment account
last_request_date timestamp In the case of recurring withdrawals, the date and time that the withdrawal was last requested
received_date timestamp Date and time that the withdrawal was received
status string Status of the transaction such as “Processing”
status_time_stamp timestamp Date and time that the status of the record was last updated
type string Indicates the payment type such as “check, “wire”, etc.
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all withdrawal requests

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/withdrawal"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all withdrawal requests
    api_response = api_instance.get_withdrawal_requests()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_withdrawal_requests: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all withdrawal requests
  result = api_instance.get_withdrawal_requests()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_withdrawal_requests: #{e}"
end
try {
    GetWithdrawalResponse result = apiInstance.getWithdrawalRequests();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getWithdrawalRequests");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getWithdrawalRequests(opts, callback);

Example Response

{
  "content": [
      {
        "id": "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969",
        "create_date": "2018-02-07T19:29:37.000+0000",
        "update_date": "2018-02-12T09:00:00.000+0000",
        "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
        "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88",
        "account_number": "bKU8LQ6gI",
        "amount": 1000.00,
        "comments": "Funds will settle on 2/11/18",
        "fees": "0",
        "last_request_date": "2018-02-10T09:00:00.000+0000",
        "received_date": "2018-02-10T09:00:00.000+0000",
        "status": "In Progress",
        "status_time_stamp": "2018-02-12T09:00:00.000+0000",
        "type": "wire",
        "withdrawal_date": "2018-02-10T10:00:00.000+0000",
        "metadata": {}
      }
  ],
  "last": true,
  "total_pages": 1,
  "total_elements": 1,
  "first": true,
  "sort": [
    {
      "direction": "DESC",
      "property": "id",
      "ignore_case": false,
      "null_handling": "NATIVE",
      "descending": true,
      "ascending": false
    }
  ],
  "number_of_elements": 1,
  "size": 25,
  "number": 0
}

Get the information for all withdrawal requests for all clients. The endpoint returns a list of UUIDs and details for each withdrawal request. You can filter using the account_id to view withdrawal requests for a specific account.

HTTP REQUEST

GET /withdrawal

Create a withdrawal request

Example Request

curl -X POST -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
              "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
              "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88",
              "account_number": "bKU8LQ6gI",
              "amount": 1000.00,
              "comments": "Funds will settle on 2/12/18",
              "fees": "0",
              "last_request_date": "2018-02-10T09:00:00.000+0000",
              "received_date": "2018-02-10T09:00:00.000+0000",
              "status": "Cleared",
              "status_time_stamp": "2018-02-12T09:00:00.000+0000",
              "type": "wire",
              "withdrawal_date": "2018-02-10T10:00:00.000+0000"
          }' "https://api.hydrogenplatform.com/nucleus/v1/withdrawal"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.WithdrawalPayload(account_id="c368c2f3-da36-480c-9193-bf75adf16274",
     funding_id="4cc15366-def0-4b39-b9b7-840a67ff9a88",
     account_number="bKU8LQ6gI",
     amount=1000,
     comments="Funds will settle on 2/12/18",
     fees="0",
     last_request_date="2018-02-10T09:00:00.000+0000",
     received_date="2018-02-10T09:00:00.000+0000",
     status="Cleared",
     status_time_stamp="2018-02-12T09:00:00.000+0000",
     type="wire",
     withdrawal_date="2018-02-10T10:00:00.000+0000")

try:
    # Create a withdrawal request
    api_response = api_instance.post_withdrawal_request(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_withdrawal_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::WithdrawalPayload.new
payload.account_id = "c368c2f3-da36-480c-9193-bf75adf16274"
payload.funding_id = "4cc15366-def0-4b39-b9b7-840a67ff9a88"
payload.account_number = "bKU8LQ6gI"
payload.amount = 1000
payload.comments = "Funds will settle on 2/12/18"
payload.fees = "0"
payload.last_request_date = "2018-02-10T09:00:00.000+0000"
payload.received_date = "2018-02-10T09:00:00.000+0000"
payload.status = "Cleared"
payload.status_time_stamp = "2018-02-12T09:00:00.000+0000"
payload.type = "wire"
payload.withdrawal_date = "2018-02-10T10:00:00.000+0000"

begin
  #Create a withdrawal request
  result = api_instance.post_withdrawal_request(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_withdrawal_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
WithdrawalPayload payload = new WithdrawalPayload(accountId="c368c2f3-da36-480c-9193-bf75adf16274",
    fundingId="4cc15366-def0-4b39-b9b7-840a67ff9a88",
    accountNumber="bKU8LQ6gI",
    amount=1000,
    comments="Funds will settle on 2/12/18",
    fees="0",
    lastRequestDate="2018-02-10T09:00:00.000+0000",
    receivedDate="2018-02-10T09:00:00.000+0000",
    status="Cleared",
    statusTimeStamp="2018-02-12T09:00:00.000+0000",
    type="wire",
    withdrawalDate="2018-02-10T10:00:00.000+0000");
try {
    CreateWithdrawalResponse result = apiInstance.postWithdrawalRequest(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postWithdrawalRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.WithdrawalPayload(accountId="c368c2f3-da36-480c-9193-bf75adf16274",
   fundingId="4cc15366-def0-4b39-b9b7-840a67ff9a88",
   accountNumber="bKU8LQ6gI",
   amount=1000,
   comments="Funds will settle on 2/12/18",
   fees="0",
   lastRequestDate="2018-02-10T09:00:00.000+0000",
   receivedDate="2018-02-10T09:00:00.000+0000",
   status="Cleared",
   statusTimeStamp="2018-02-12T09:00:00.000+0000",
   type="wire",
   withdrawalDate="2018-02-10T10:00:00.000+0000");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postWithdrawalRequest(payload, callback);

Example Response

{
    "id": "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969",
    "create_date": "2018-02-12T09:00:00.000+0000",
    "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
    "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88",
    "account_number": "bKU8LQ6gI",
    "amount": 1000.00,
    "comments": "Funds will settle on 2/12/18",
    "fees": "0",
    "last_request_date": "2018-02-10T09:00:00.000+0000",
    "received_date": "2018-02-10T09:00:00.000+0000",
    "status": "Cleared",
    "status_time_stamp": "2018-02-12T09:00:00.000+0000",
    "type": "wire",
    "withdrawal_date": "2018-02-10T10:00:00.000+0000",
    "metadata": {}
}

Create a new withdrawal request for an account. The unique account_id for the withdrawal must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all the accounts defined for your firm. The create_date will default to the current date. The endpoint returns a unique withdrawal_id used to manage the withdrawal request.

HTTP REQUEST

POST /withdrawal

ARGUMENTS

Parameter Type Required Description
account_id UUID required The id for the account that is the destination of the withdrawal
amount double required Amount that is being withdrawn from the account
funding_id UUID required The id of the funding record that maps to this withdrawal
withdrawal_date timestamp required Date and time that the withdrawal was made
account_number string optional Bank account number that is the destination of the withdrawal
comments string optional Comment for the withdrawal such as “Funded”
direction string optional Label to indicate the direction of the transaction such as “Incoming” or “Outgoing”
fees string optional Any fees associated with the withdrawal, especially for an investment account
last_request_date timestamp optional In the case of recurring withdrawals, the date and time that the withdrawal was last requested
received_date timestamp optional Date and time that the withdrawal was received
status string optional Status of the transaction such as “Processing”
status_time_stamp timestamp optional Date and time that the status of the record was last updated
type string optional Indicates the payment type such as “check, “wire”, etc.
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a withdrawal request

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/withdrawal/be07c93a-c0b0-4fb0-97e1-3a0f77b8c969"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'

try:
    # Retrieve a withdrawal request
    api_response = api_instance.get_withdrawal_request(withdrawal_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_withdrawal_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'

begin
  #Retrieve a withdrawal request
  result = api_instance.get_withdrawal_request(withdrawal_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_withdrawal_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID withdrawalId = new UUID("be07c93a-c0b0-4fb0-97e1-3a0f77b8c969");
try {
    SpecificWithdrawalResponse result = apiInstance.getWithdrawalRequest(withdrawalId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getWithdrawalRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var withdrawalId = "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getWithdrawalRequest(withdrawalId, callback);

Example Response

{
    "id": "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
    "account_number": "bKU8LQ6gI",
    "amount": 1000.00,
    "comments": "Funds will settle on 2/12/18",
    "fees": "0",
    "last_request_date": "2018-02-10T09:00:00.000+0000",
    "received_date": "2018-02-10T09:00:00.000+0000",
    "status": "Cleared",
    "status_time_stamp": "2018-02-12T09:00:00.000+0000",
    "type": "wire",
    "withdrawal_date": "2018-02-10T10:00:00.000+0000",
    "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88",
    "metadata": {}
}

Retrieve the information for a withdrawal request for an account. The unique withdrawal_id must be provided. The endpoint returns the details for the withdrawal request specified.

HTTP REQUEST

GET /withdrawal/{withdrawal_id}

Update a withdrawal request

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
            "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
            "account_number": "bKU8LQ6gI",
            "amount": 1000.00,
            "comments": "Funds will settle on 2/12/18",
            "fees": "0",
            "last_request_date": "2018-02-10T09:00:00.000+0000",
            "received_date": "2018-02-10T09:00:00.000+0000",
            "status": "Cleared",
            "status_time_stamp": "2018-02-12T09:00:00.000+0000",
            "type": "wire",
            "withdrawal_date": "2018-02-10T10:00:00.000+0000",
            "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88"
        }' "https://api.hydrogenplatform.com/nucleus/v1/withdrawal/be07c93a-c0b0-4fb0-97e1-3a0f77b8c969"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'
payload = atom_api.WithdrawalPayload(account_id="c368c2f3-da36-480c-9193-bf75adf16274",
     account_number="bKU8LQ6gI",
     amount=1000,
     comments="Funds will settle on 2/12/18",
     fees="0",
     last_request_date="2018-02-10T09:00:00.000+0000",
     received_date="2018-02-10T09:00:00.000+0000",
     status="Cleared",
     status_time_stamp="2018-02-12T09:00:00.000+0000",
     type="wire",
     withdrawal_date="2018-02-10T10:00:00.000+0000",
     funding_id="4cc15366-def0-4b39-b9b7-840a67ff9a88",)

try:
    # Update a withdrawal request
    api_response = api_instance.update_withdrawal_request(withdrawal_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_withdrawal_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'

payload = AtomApi::WithdrawalPayload.new
payload.account_id = "c368c2f3-da36-480c-9193-bf75adf16274"
payload.account_number = "bKU8LQ6gI"
payload.amount = 1000
payload.comments = "Funds will settle on 2/12/18"
payload.fees = "0"
payload.last_request_date = "2018-02-10T09:00:00.000+0000"
payload.received_date = "2018-02-10T09:00:00.000+0000"
payload.status = "Cleared"
payload.status_time_stamp = "2018-02-12T09:00:00.000+0000"
payload.type = "wire"
payload.withdrawal_date = "2018-02-10T10:00:00.000+0000"
payload.funding_id = "4cc15366-def0-4b39-b9b7-840a67ff9a88"

begin
  #Update a withdrawal request
  result = api_instance.update_withdrawal_request(withdrawal_idpayload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_withdrawal_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID withdrawalId = new UUID("be07c93a-c0b0-4fb0-97e1-3a0f77b8c969");
WithdrawalPayload payload = new WithdrawalPayload(accountId="c368c2f3-da36-480c-9193-bf75adf16274",
      accountNumber="bKU8LQ6gI",
      amount=1000,
      comments="Funds will settle on 2/12/18",
      fees="0",
      lastRequestDate="2018-02-10T09:00:00.000+0000",
      receivedDate="2018-02-10T09:00:00.000+0000",
      status="Cleared",
      statusTimeStamp="2018-02-12T09:00:00.000+0000",
      type="wire",
      withdrawalDate="2018-02-10T10:00:00.000+0000",
      fundingId="4cc15366-def0-4b39-b9b7-840a67ff9a88");
try {
    SpecificWithdrawalResponse result = apiInstance.updateWithdrawalRequest(withdrawalId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateWithdrawalRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var withdrawalId = "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969";

var payload = new atom_api.WithdrawalPayload(accountId="c368c2f3-da36-480c-9193-bf75adf16274",
     accountNumber="bKU8LQ6gI",
     amount=1000,
     comments="Funds will settle on 2/12/18",
     fees="0",
     lastRequestDate="2018-02-10T09:00:00.000+0000",
     receivedDate="2018-02-10T09:00:00.000+0000",
     status="Cleared",
     statusTimeStamp="2018-02-12T09:00:00.000+0000",
     type="wire",
     withdrawalDate="2018-02-10T10:00:00.000+0000",
     fundingId="4cc15366-def0-4b39-b9b7-840a67ff9a88");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateWithdrawalRequest(withdrawalIdpayload, callback);

Example Response

{
    "id": "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "account_id": "c368c2f3-da36-480c-9193-bf75adf16274",
    "account_number": "bKU8LQ6gI",
    "amount": 1000.00,
    "comments": "Funds will settle on 2/12/18",
    "fees": "0",
    "last_request_date": "2018-02-10T09:00:00.000+0000",
    "received_date": "2018-02-10T09:00:00.000+0000",
    "status": "Cleared",
    "status_time_stamp": "2018-02-12T09:00:00.000+0000",
    "type": "wire",
    "withdrawal_date": "2018-02-10T10:00:00.000+0000",
    "funding_id": "4cc15366-def0-4b39-b9b7-840a67ff9a88",
    "metadata": {}
}

Update the information for a withdrawal request for an account. The unique withdrawal_id must be provided. To obtain the appropriate withdrawal_id, use the GET /withdrawal endpoint to view all withdrawal requests defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the withdrawal_id and all of the details for the withdrawal request.

HTTP REQUEST

PUT /withdrawal/{withdrawal_id}

Delete a withdrawal request

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/withdrawal/be07c93a-c0b0-4fb0-97e1-3a0f77b8c969"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'

try:
    # Delete a withdrawal request
    api_instance.delete_withdrawal_request(withdrawal_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_withdrawal_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

withdrawal_id = 'be07c93a-c0b0-4fb0-97e1-3a0f77b8c969'

begin
  #Delete a withdrawal request
  api_instance.delete_withdrawal_request(withdrawal_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_withdrawal_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID withdrawalId = new UUID("be07c93a-c0b0-4fb0-97e1-3a0f77b8c969");
try {
    apiInstance.deleteWithdrawalRequest(withdrawalId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteWithdrawalRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var withdrawalId = "be07c93a-c0b0-4fb0-97e1-3a0f77b8c969";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteWithdrawalRequest(withdrawalId, callback);

Response (204 No Content)

Permanently delete a withdrawal request from an account. The unique withdrawal_id must be provided. To obtain the appropriate withdrawal_id, use the GET /withdrawal endpoint to view all withdrawal requests defined for your firm. This deletes the withdrawal_id and the withdrawal request record.

HTTP REQUEST

DELETE /withdrawal/{withdrawal_id}

Transfer

External account transfer represent links between an external account (ex. an external retirement investing account such as a Roth IRA) to a client account on your firm’s platform to transfer funds or existing holdings. External account transfers are used for funding purposes similar to bank links.

Field Type Description
id UUID The id for the specific transfer
account_id UUID The id of the account to which the transfer belongs
account_holder string Name of the individual that is the owner of the external account
account_number string Account number for the external account that is the source of the funds
account_type_id UUID The id for the type of the account on your platform
firm_name string Name of the firm that previously held or holds the external account
transfer_all_cash boolean Indicator if the external account should be entirely converted to cash to be transferred.
amount double Amount that is transferred
comment string Comment for the transfer such as “Funded”
dtc_number string Number of the Deposit Trust Company (DTC)’s that held or holds the external account usually in the case of an Individual Retirement Account (IRA) in the United States
roth_five_year integer In the case that the account is a United States Roth IRA account, the year it was opened (e.g. 2010)
status string Status of the transfer such as “Pending”
status_time_stamp timestamp Timestamp for the date and time that the status was last updated
transfer_type string Type of transaction being made such as “wire” or “check”
transfer_date date Date that the transfer will be initiated. Defaults to the current date
received_date timestamp Timestamp for the date and time that the transfer was received
metadata map Custom information associated with the entity in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all transfer requests

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/transfer"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all transfer requests
    api_response = api_instance.get_transfer_requests()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_transfer_requests: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all transfer requests
  result = api_instance.get_transfer_requests()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_transfer_requests: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetTransferResponse result = apiInstance.getTransferRequests();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getTransferRequests");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getTransferRequests(opts, callback);

Example Response

{
    "content": [
      {
        "id": "111d714c-1d1c-47cf-9cb7-760428e86c24",
        "transfer_date": "2019-03-21",
        "create_date": "2018-04-09T21:02:11.000+0000",
        "update_date": "2018-04-09T21:02:11.000+0000",
        "account_holder": "JB Smith",
        "account_number": "5889632503",
        "amount": 13000,
        "comment": "Closed down previous 401k",
        "firm_name": "Vanguard",
        "status": "Pending",
        "status_time_stamp": "2018-04-09T21:02:11.000+0000",
        "transfer_all_cash": true,
        "transfer_type": "WIRE",
        "account_id": "099961da-7f41-4309-950f-2b51689a0033",
        "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
        "metadata": {}
      },
      {
        "id": "1b19a750-f3c6-46e7-9131-fe11f06314ea",
        "transfer_date": "2018-04-08",
        "received_date": "2018-04-09T20:52:07.000+0000",
        "create_date": "2018-04-09T20:52:07.000+0000",
        "update_date": "2018-04-09T20:52:07.000+0000",
        "account_holder": "John Smith",
        "account_number": "5889632592",
        "amount": 13000,
        "comment": "Closed down previous 401k",
        "firm_name": "Vanguard",
        "status": "Pending",
        "transfer_all_cash": true,
        "transfer_type": "WIRE",
        "account_id": "04907eaa-3f33-49be-a35b-378cdf639fba",
        "account_type_id": "eb3d7f60-a133-4ca9-815f-3677bcdc23a3",
        "metadata": {}
      },
      {
        "id": "93197309-ff29-458a-ac9d-ad24ac2d95c9",
        "transfer_date": "2018-04-08",
        "received_date": "2018-04-09T20:29:04.000+0000",
        "create_date": "2018-04-09T20:29:04.000+0000",
        "update_date": "2018-04-09T20:29:04.000+0000",
        "account_holder": "Dan Lars",
        "account_number": "6009632590",
        "amount": 34000,
        "comment": "Closed down previous 401k",
        "firm_name": "Vanguard",
        "status": "Pending",
        "transfer_all_cash": true,
        "account_id": "107516c3-9035-4811-af7c-501be5a1fe26",
        "account_type_id": "39770e8d-890d-485b-822e-5a1578f26d47",
        "metadata": {}
      }
    ],
    "total_elements": 3,
    "last": true,
    "total_pages": 1,
    "first": true,
    "sort": [
        {
            "direction": "DESC",
            "property": "updateDate",
            "ignore_case": false,
            "null_handling": "NATIVE",
            "ascending": false,
            "descending": true
        }
    ],
    "number_of_elements": 5,
    "size": 25,
    "number": 0
}

Get the information for all external account transfers defined for your firm. The endpoint returns a list of UUIDs and details for each external account transfer. You can filter by account_id to view external account transfers for a specific account.

HTTP REQUEST

GET /transfer

Create a transfer request

Example Request

curl -X POST -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
              "account_holder": "JB Smith",
              "account_number": "5889632503",
              "amount": 13000,
              "comment": "Closed down previous 401k",
              "firm_name": "Vanguard",
              "dtc_number" : "345928204",
              "status": "Pending",
              "status_time_stamp": "2018-04-09T21:02:11.000+0000",
              "transfer_all_cash": true,
              "transfer_type": "WIRE",
              "transfer_date": "2019-03-21",
              "account_id": "099961da-7f41-4309-950f-2b51689a0033",
              "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3"
        }' "https://api.hydrogenplatform.com/nucleus/v1/transfer"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.TransferRequestPayload(account_holder="JB Smith",
      account_number="5889632503",
      amount=13000,
      comment="Closed down previous 401k",
      firm_name="Vanguard",
      dtc_number="345928204",
      status="Pending",
      transfer_all_cash=True,
      transfer_type="WIRE",
      account_id="099961da-7f41-4309-950f-2b51689a0033",
      account_type_id="647c54c3-b649-477e-8cc7-eee56a120dd3")

try:
    # Create a transfer request
    api_response = api_instance.post_transfer_request(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_transfer_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::TransferRequestPayload.new
payload.account_holder = "JB Smith"
payload.account_number = "5889632503"
payload.amount = 13000
payload.comment = "Closed down previous 401k"
payload.firm_name = "Vanguard"
payload.dtc_number = "345928204"
payload.status = "Pending"
payload.transfer_all_cash = true
payload.transfer_type = "WIRE"
payload.account_id = "099961da-7f41-4309-950f-2b51689a0033"
payload.account_type_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"

begin
  #Create a transfer request
  result = api_instance.post_transfer_request(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_transfer_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
TransferRequestPayload payload = new TransferRequestPayload(accountHolder="JB Smith",
      accountNumber="5889632503",
      amount=13000,
      comment="Closed down previous 401k",
      firmName="Vanguard",
      dtcNumber="345928204",
      status="Pending",
      transferAllCash=true,
      transferType="WIRE",
      accountId="099961da-7f41-4309-950f-2b51689a0033",
      accountTypeId="647c54c3-b649-477e-8cc7-eee56a120dd3");
try {
    CreateTransferResponse result = apiInstance.postTransferRequest(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postTransferRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.TransferRequestPayload(accountHolder="JB Smith",
      accountNumber="5889632503",
      amount=13000,
      comment="Closed down previous 401k",
      firmName="Vanguard",
      dtcNumber="345928204",
      status="Pending",
      transferAllCash=true,
      transferType="WIRE",
      accountId="099961da-7f41-4309-950f-2b51689a0033",
      accountTypeId="647c54c3-b649-477e-8cc7-eee56a120dd3");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postTransferRequest(payload, callback);

Example Response

{
    "id": "111d714c-1d1c-47cf-9cb7-760428e86c24",
    "transfer_date": "2019-03-21",
    "create_date": "2018-04-09T21:02:11.000+0000",
    "account_holder": "JB Smith",
    "account_number": "5889632503",
    "amount": 13000,
    "comment": "Closed down previous 401k",
    "firm_name": "Vanguard",
    "dtc_number" : "345928204",
    "status": "Pending",
    "status_time_stamp": "2018-04-09T21:02:11.000+0000",
    "transfer_all_cash": true,
    "transfer_type": "WIRE",
    "account_id": "099961da-7f41-4309-950f-2b51689a0033",
    "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3"
}

Create a new external account transfer for a client account. The unique account_id must be provided. To obtain the appropriate account_id, use the GET /account endpoint to view all accounts defined for your firm. The create_date will default to the current date. The endpoint returns a unique transfer_id used to manage the deposit request.

HTTP REQUEST

POST /transfer

ARGUMENTS

Parameter Type Required Description
account_id UUID required The id of the account to which the transfer belongs
account_holder string required Name of the individual that is the owner of the external account
account_number string required Account number for the external account that is the source of the funds
account_type_id UUID required The id for the type of the account on your platform
firm_name string required Name of the firm that previously held or holds the external account
transfer_all_cash boolean required Indicator if the external account should be entirely converted to cash to be transferred.
amount double optional Amount that is transferred
comment string optional Comment for the transfer such as “Funded”
dtc_number string optional Number of the Deposit Trust Company (DTC)’s that held or holds the external account usually in the case of an Individual Retirement Account (IRA) in the United States
roth_five_year integer optional In the case that the account is a United States Roth IRA account, the year it was opened (e.g. 2010)
status string optional Status of the transfer such as “Pending”
transfer_type string optional Type of transaction being made such as “wire” or “check”
transfer_date date optional Date that the transfer will be initiated. Defaults to the current date
metadata map optional Custom information associated with the entity in the format key:value
See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a transfer request

Example Request

curl -X GET -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    "https://api.hydrogenplatform.com/nucleus/v1/transfer/111d714c-1d1c-47cf-9cb7-760428e86c24"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'

try:
    # Retrieve a transfer request
    api_response = api_instance.get_transfer_request(transfer_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_transfer_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'

begin
  #Retrieve a transfer request
  result = api_instance.get_transfer_request(transfer_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_transfer_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID transferId = new UUID("111d714c-1d1c-47cf-9cb7-760428e86c24");
try {
    SpecificTransferResponse result = apiInstance.getTransferRequest(transferId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getTransferRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var transferId = "111d714c-1d1c-47cf-9cb7-760428e86c24";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getTransferRequest(transferId, callback);

Example Response

{
    "id": "111d714c-1d1c-47cf-9cb7-760428e86c24",
    "transfer_date": "2019-03-21",
    "create_date": "2018-04-09T21:02:11.000+0000",
    "update_date": "2018-04-09T21:02:11.000+0000",
    "account_holder": "JB Smith",
    "account_number": "5889632503",
    "amount": 13000,
    "comment": "Closed down previous 401k",
    "firm_name": "Vanguard",
    "dtc_number" : "345928204",
    "status": "Pending",
    "status_time_stamp": "2018-04-09T21:02:11.000+0000",
    "transfer_all_cash": true,
    "transfer_type": "WIRE",
    "account_id": "099961da-7f41-4309-950f-2b51689a0033",
    "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "metadata": {}
}

Retrieve the information for a external account transfer for an account. The unique transfer_id must be provided. The endpoint returns the details for the external account transfer specified.

HTTP REQUEST

GET /transfer/{transfer_id}

Update a transfer request

Example Request

curl -X PUT -H "Authorization: Bearer 7f137375-c63b-49fb-84eb-5abbd3b780a3" \
    -H "Content-Type: application/json" \
    -d '{
              "account_holder": "JB Smith",
              "account_number": "5889632503",
              "amount": 13000,
              "comment": "Closed down previous 401k",
              "firm_name": "Vanguard",
              "dtc_number" : "345928204",
              "status": "Pending",
              "status_time_stamp": "2018-04-09T21:02:11.000+0000",
              "transfer_all_cash": true,
              "transfer_type": "WIRE",
              "transfer_date": "2019-03-21",
              "account_id": "099961da-7f41-4309-950f-2b51689a0033",
              "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3"
         }' "https://api.hydrogenplatform.com/nucleus/v1/transfer/111d714c-1d1c-47cf-9cb7-760428e86c24"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'
payload = atom_api.TransferRequestPayload(account_holder="JB Smith",
    account_number="5889632503",
    amount=13000,
    comment="Closed down previous 401k",
    firm_name="Vanguard",
    dtc_number="345928204",
    status="Pending",
    transfer_all_cash=True,
    transfer_type="WIRE",
    account_id="099961da-7f41-4309-950f-2b51689a0033",
    account_type_id="647c54c3-b649-477e-8cc7-eee56a120dd3")

try:
    # Update a transfer request
    api_response = api_instance.update_transfer_request(transfer_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_transfer_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'

payload = AtomApi::TransferRequestPayload.new
payload.account_holder = "JB Smith"
payload.account_number = "5889632503"
payload.amount = 13000
payload.comment = "Closed down previous 401k"
payload.firm_name = "Vanguard"
paylooad.dtc_number = "345928204"
payload.status = "Pending"
payload.transfer_all_cash = true
payload.transfer_type = "WIRE"
payload.account_id = "099961da-7f41-4309-950f-2b51689a0033"
payload.account_type_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"

begin
  #Update a transfer request
  result = api_instance.update_transfer_request(transfer_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_transfer_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID transferId = new UUID("111d714c-1d1c-47cf-9cb7-760428e86c24");
TransferRequestPayload payload = new TransferRequestPayload(accountHolder="JB Smith",
        accountNumber="5889632503",
        amount=13000,
        comment="Closed down previous 401k",
        firmName="Vanguard",
        dtcNumber="345928204",
        status="Pending",
        transferAllCash=true,
        transferType="WIRE",
        accountId="099961da-7f41-4309-950f-2b51689a0033",
        accountTypeId="647c54c3-b649-477e-8cc7-eee56a120dd3");
try {
    SpecificTransferResponse result = apiInstance.updateTransferRequest(transferId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateTransferRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var transferId = "111d714c-1d1c-47cf-9cb7-760428e86c24";

var payload = new atom_api.TransferRequestPayload(accountHolder="JB Smith",
      accountNumber="5889632503",
      amount=13000,
      comment="Closed down previous 401k",
      firmName="Vanguard",
      dtcNumber="345928204",
      status="Pending",
      transferAllCash=true,
      transferType="WIRE",
      accountId="099961da-7f41-4309-950f-2b51689a0033",
      accountTypeId="647c54c3-b649-477e-8cc7-eee56a120dd3");

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateTransferRequest(transferIdpayload, callback);

Example Response

{
    "id": "111d714c-1d1c-47cf-9cb7-760428e86c24",
    "transfer_date": "2019-03-21",
    "create_date": "2018-04-09T21:02:11.000+0000",
    "update_date": "2018-04-09T21:02:11.000+0000",
    "account_holder": "JB Smith",
    "account_number": "5889632503",
    "amount": 13000,
    "comment": "Closed down previous 401k",
    "firm_name": "Vanguard",
    "dtc_number" : "345928204",
    "status": "Pending",
    "status_time_stamp": "2018-04-09T21:02:11.000+0000",
    "transfer_all_cash": true,
    "transfer_type": "WIRE",
    "account_id": "099961da-7f41-4309-950f-2b51689a0033",
    "account_type_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "metadata": {}
}

Update the information for a external account transfer for a client account. The unique transfer_id must be provided. To obtain the appropriate transfer_id, use the GET /transfer endpoint to view all external account transfer requests defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the transfer_id and all of the details for the external account transfer.

HTTP REQUEST

PUT /transfer/{transfer_id}

Delete a transfer request

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/transfer/111d714c-1d1c-47cf-9cb7-760428e86c24"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'

try:
    # Delete a transfer request
    api_instance.delete_transfer_request(transfer_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_transfer_request: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

transfer_id = '111d714c-1d1c-47cf-9cb7-760428e86c24'

begin
  #Delete a transfer request
  api_instance.delete_transfer_request(transfer_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_transfer_request: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID transferId = new UUID("111d714c-1d1c-47cf-9cb7-760428e86c24");
try {
    apiInstance.deleteTransferRequest(transferId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteTransferRequest");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var transferId = "111d714c-1d1c-47cf-9cb7-760428e86c24";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteTransferRequest(transferId, callback);

Response (204 No Content)

Permanently delete a external account transfer from a client account. The unique transfer_id must be provided. To obtain the appropriate transfer_id, use the GET /transfer endpoint to view all external account transfer requests defined for your firm. This deletes the transfer_id and the external account transfer record.

HTTP REQUEST

DELETE /transfer/{transfer_id}

Goal

Goal frameworks are defined firm-wide. Clients can answer a questionnaire created by your firm in order to customize their goals based upon their specific needs. Questionnaires can be assigned to multiple goals, using a questionnaire_id. Client responses to the goal questionnaire are stored and used as variables in future calculations. The progress of each client is tracked in relation to one or more goals that the client has selected. A client may have multiple goals, and each goal may belong to one or more of the client’s accounts.

Field Type Description
id UUID The id of the goal
name string Name of the goal
parent_goal_id UUID In the case that a goal is related to a broader goal, the id of the broader goal
questionnaire_id UUID The id of the group of questions that are used to customize a goal for a client
is_decumulation boolean Indicator for whether or not the goal is a decumulation goal such as saving for retirement. Default is false, indicating that the goal is an accumulation goal. May be used in conjunction with the Proton API.
type string Type of goal used to identify similar goals. Can be used to differentiate between goal templates and client-specific goals
category string Category of the goal used to group goals together. For example, different large purchase goals could have a category of ‘Major Purchase’
client_id UUID If the goal is client-specific (not used by any other client), the id of the client to which it belongs
goal_amount double If the goal is client-specific, the target monetary amount to be reached within the goal horizon. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
accumulation_horizon double If the goal is client-specific, the time horizon of the goal during the accumulation phase, in years. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
decumulation_horizon double If the goal is client-specific, the time horizon of the goal during the decumulation phase, in years. If the goal is an accumulation goal, then this can be 0 or omitted entirely. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
is_active string Indicates if the goal is active. Defaults to true which indicates it is active
metadata map Custom information associated with the goal in the format key:value. See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Goal Management

List all goals

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all goals
    api_response = api_instance.get_goals()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goals: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all goals
  result = api_instance.get_goals()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goals: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
try {
    GetGoalResponse result = apiInstance.getGoals();
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getGoals");
    e.printStackTrace();
}

var apiInstance = new atom_api.NucleusApi();

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getGoals(opts, callback);

Example Response

{
  "content": [
      {
          "id": "bab849d6-de96-4dc7-a5ea-19be45c52a4e",
          "create_date": "2018-02-07T19:29:37.000+0000",
          "update_date": "2018-02-12T09:00:00.000+0000",
          "name": "House",
          "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "is_decumulation": false,
          "type": "Client Goal",
          "category": "Large Purchase",
          "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
          "goal_amount": 100000,
          "accumulation_horizon": 10,
          "decumulation_horizon": 0,
          "is_active": true,
          "metadata": {
              "image": "https://www.hydrogenplatform.com/images/demo/house.svg"
          }
      },
      {
          "id": "e995d4c1-f989-4733-9867-713966ac9856",
          "create_date": "2018-02-07T19:29:37.000+0000",
          "update_date": "2018-02-12T09:00:00.000+0000",
          "name": "Car",
          "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "is_decumulation": false,
          "type": "Client Goal",
          "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
          "category": "Large Purchase",
          "goal_amount": 10000,
          "accumulation_horizon": 5,
          "decumulation_horizon": 0,
          "is_active": true,
          "metadata": {
              "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
          }
      },
      {
          "id": "fbc03484-08e8-446d-83aa-6d6cc236355e",
          "create_date": "2018-02-07T19:29:37.000+0000",
          "update_date": "2018-02-12T09:00:00.000+0000",
          "name": "Vacation",
          "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
          "is_decumulation": false,
          "type": "Client Goal",
          "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
          "category": "Large Purchase",
          "goal_amount": 1000,
          "accumulation_horizon": 3,
          "is_active": true,
          "metadata": {
              "image": "https://www.hydrogenplatform.com/images/demo/travel.svg"
          }
      },
  ],
  "total_pages": 1,
  "total_elements": 3,
  "last": true,
  "number_of_elements": 3,
  "first": true,
  "sort": [
      {
        "direction": "ASC",
        "property": "id",
        "ignore_case": false,
        "null_handling": "NATIVE",
        "descending": false,
        "ascending": true
      }
  ],
  "size": 25,
  "number": 0
}

Get the details for all goals defined by your firm. Note that the metadata information is stored as a nested object within the goal object.

HTTP REQUEST

GET /goal

Create a goal

Example Request

curl -X POST -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" \
     -d '{
            "name": "Car",
            "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "is_decumulation": false,
            "type": "Client Goal",
            "category": "Large Purchase",
            "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
            "goal_amount": 100000,
            "accumulation_horizon": 10,
            "decumulation_horizon": 0,
            "metadata": {
              "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
            }
      }' "https://api.hydrogenplatform.com/nucleus/v1/goal"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
payload = atom_api.GoalPayload(name="Car",
     parent_goal_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
     questionnaire_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
     is_decumulation=False,
     type="Client Goal",
     category="Large Purchase",
     client_id="184b66ff-09d8-4c0d-ad88-c7d7e8376714",
     goal_amount=100000,
     accumulation_horizon=10,
     decumulation_horizon=0,
     metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"})

try:
    # Create a goal
    api_response = api_instance.post_goal(payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->post_goal: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

payload = AtomApi::GoalPayload.new
payload.name = "Car"
payload.parent_goal_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
payload.questionnaire_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
payload.is_decumulation = false
payload.type = "Client Goal"
payload.category = "Large Purchase"
payload.client_id = "184b66ff-09d8-4c0d-ad88-c7d7e8376714"
payload.goal_amount = 100000
payload.accumulation_horizon = 10
payload.decumulation_horizon = 0
payload.metadata = {image => "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"}

begin
  #Create a goal
  result = api_instance.post_goal(payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->post_goal: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
GoalPayload payload = new GoalPayload(name="Car",
    parentGoalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    questionnaireId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    isDecumulation=false,
    type="Client Goal",
    category="Large Purchase",
    clientId="184b66ff-09d8-4c0d-ad88-c7d7e8376714",
    goalAmount=100000,
    accumulationHorizon=10,
    decumulationHorizon=0,
    metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"});
try {
    CreateGoalResponse result = apiInstance.postGoal(payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#postGoal");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var payload = new atom_api.GoalPayload(name="Car",
    parentGoalId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    questionnaireId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    isDecumulation=false,
    type="Client Goal",
    category="Large Purchase",
    clientId="184b66ff-09d8-4c0d-ad88-c7d7e8376714",
    goalAmount=100000,
    accumulationHorizon=10,
    decumulationHorizon=0,
    metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"});

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.postGoal(payload, callback);

Example Response

{
    "id": "e995d4c1-f989-4733-9867-713966ac9856",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "name": "Car",
    "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "is_decumulation": false,
    "type": "Client Goal",
    "category": "Large Purchase",
    "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
    "goal_amount": 100000,
    "accumulation_horizon": 10,
    "decumulation_horizon": 0,
    "is_active": true,
    "metadata": {
        "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
    }
}

Create a new goal for your firm that clients can customize for themselves. Must provide the name for the goal and indicate whether or not the goal is a decumulation goal (or accumulation goal). The create_date will default to the current date. The endpoint returns the goal_id used to manage the goal and to map the goal to a client.

HTTP REQUEST

POST /goal

ARGUMENTS

Parameter Type Required Description
name string required Name of the goal
parent_goal_id UUID optional In the case that a goal is related to a broader goal, the id of the broader goal
questionnaire_id UUID optional The id of the group of questions that are used to customize a goal for a client
is_decumulation boolean optional Indicator if the goal is a decumulation goal such as saving for retirement. Default is false, indicating that the goal is an accumulation goal. May be used in conjunction with the Proton API.
type string optional Type of goal used to identify similar goals. Can be used to differentiate between goal templates and client-specific goals
category string optional Category of the goal used to group goals together. For example, different large purchase goals could have a category of ‘Major Purchase’
client_id UUID optional If the goal is client-specific (not used by any other client), the id of the client to which it belongs
goal_amount double optional If the goal is client-specific, the target monetary amount to be reached within the goal horizon. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
accumulation_horizon double optional If the goal is client-specific, the time horizon of the goal during the accumulation phase, in years. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
decumulation_horizon double optional If the goal is client-specific, the time horizon of the goal during the decumulation phase, in years. If the goal is an accumulation goal, then this can be 0 or omitted entirely. May be used in conjunction with the Proton API. If the goal is not client-specific, please store under the account entity.
is_active string optional Indicates if the goal is active. Defaults to true which indicates it is active
metadata map optional Custom information associated with the goal in the format key:value. See Metadata
secondary_id string optional Alternate id that can be used to identify the object such as an internal id

Retrieve a goal

Example Request

curl -X GET -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal/e995d4c1-f989-4733-9867-713966ac9856"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'

try:
    # Retrieve a goal
    api_response = api_instance.get_goal(goal_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goal: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'

begin
  #Retrieve a goal
  result = api_instance.get_goal(goal_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goal: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("e995d4c1-f989-4733-9867-713966ac9856");
try {
    SpecificGoalResponse result = apiInstance.getGoal(goalId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getGoal");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "e995d4c1-f989-4733-9867-713966ac9856";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getGoal(goalId, , callback);

Example Response

{
    "id": "e995d4c1-f989-4733-9867-713966ac9856",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "name": "Car",
    "parent_goal_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "is_decumulation": false,
    "type": "Client Goal",
    "category": "Large Purchase",
    "client_id": "184b66ff-09d8-4c0d-ad88-c7d7e8376714",
    "goal_amount": 100000,
    "accumulation_horizon": 10,
    "decumulation_horizon": 0,
    "is_active": true,
    "metadata": {
        "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
      }
}

Retrieve the information for a goal defined for your firm. The goal_id must be provided. The endpoint returns the goal_id and the details for the goal specified.

HTTP REQUEST

GET /goal/{goal_id}

Update a goal

Example Request

curl -X PUT -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
     -H "Content-Type: application/json" \
     -d '{
            "name": "Car",
            "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
            "type": "Goal Template",
            "category": "Large Purchase",
            "is_active": false,
            "metadata": {
               "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
            }
        }' "https://api.hydrogenplatform.com/nucleus/v1/goal/e995d4c1-f989-4733-9867-713966ac9856"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'
payload = atom_api.GoalPayload(name="Car",
   questionnaire_id="647c54c3-b649-477e-8cc7-eee56a120dd3",
   type="Goal Template",
   category="Large Purchase",
   is_active=False,
   metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"})

try:
    # Update a goal
    api_response = api_instance.update_goal(goal_id, payload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->update_goal: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'

payload = AtomApi::GoalPayload.new
payload.name = "Car"
payload.questionnaire_id = "647c54c3-b649-477e-8cc7-eee56a120dd3"
payload.type = "Goal Template"
payload.category = "Large Purchase"
payload.is_active = false
payload.metadata = {image => "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"}

begin
  #Update a goal
  result = api_instance.update_goal(goal_id, payload)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->update_goal: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("e995d4c1-f989-4733-9867-713966ac9856");
GoalPayload payload = new GoalPayload(name="Car",
    questionnaireId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    type="Goal Template",
    category="Large Purchase",
    isActive=false,
    metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"});
try {
    SpecificGoalResponse result = apiInstance.updateGoal(goalId, payload);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#updateGoal");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "e995d4c1-f989-4733-9867-713966ac9856";

var payload = new atom_api.GoalPayload(name="Car",
    questionnaireId="647c54c3-b649-477e-8cc7-eee56a120dd3",
    type="Goal Template",
    category="Large Purchase",
    isActive=false,
    metadata={"image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"});

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.updateGoal(goalId, payload, callback);

Example Response

{
    "id": "e995d4c1-f989-4733-9867-713966ac9856",
    "create_date": "2018-02-07T19:29:37.000+0000",
    "update_date": "2018-02-12T09:00:00.000+0000",
    "name": "Car",
    "questionnaire_id": "647c54c3-b649-477e-8cc7-eee56a120dd3",
    "is_decumulation": false,
    "type": "Goal Template",
    "category": "Large Purchase",
    "is_active": false,
    "metadata": {
         "image": "https://www.hydrogenplatform.com/images/demo/car-purchase.svg"
    }
}

Update a goal defined for your firm. The goal_id must be provided. To obtain the appropriate goal_id, use the GET /goal endpoint to view all goals defined for your firm and their current information. The details to be updated must also be provided. The endpoint returns the goal_id and the details for the goal.

HTTP REQUEST

PUT /goal/{goal_id}

Delete a goal

Example Request

curl -X DELETE -H "Authorization: Bearer e7cf805b-4307-41e9-8b58-90b6359fa900" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal/e995d4c1-f989-4733-9867-713966ac9856"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'

try:
    # Delete a goal
    api_instance.delete_goal(goal_id)
except ApiException as e:
    print("Exception when calling NucleusApi->delete_goal: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = 'e995d4c1-f989-4733-9867-713966ac9856'

begin
  #Delete a goal
  api_instance.delete_goal(goal_id)
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->delete_goal: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("e995d4c1-f989-4733-9867-713966ac9856");
try {
    apiInstance.deleteGoal(goalId);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#deleteGoal");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "e995d4c1-f989-4733-9867-713966ac9856";

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
apiInstance.deleteGoal(goalId, , callback);

Response (204 No Content)

Permanently delete a goal for your firm. The goal_id must be provided. To obtain the appropriate goal_id, use the GET /goal endpoint to view all goals defined for your firm. This deletes the goal_id and the goal record so that the goal can no longer be used overall.

HTTP REQUEST

DELETE /goal/{goal_id}

Goal Activity

List goal asset sizes

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal/8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0/asset_size?client_id=b4c033db-9d05-4a33-8e28-40650d454487"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'
client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

try:
    # List goal asset sizes
    api_response = api_instance.get_goal_asset_sizes(goal_id, client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goal_asset_sizes: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = '8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0'

client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

begin
  #List goal asset sizes
  result = api_instance.get_goal_asset_sizes(goal_id, client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goal_asset_sizes: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0");
UUID clientId = new UUID("b4c033db-9d05-4a33-8e28-40650d454487");
try {
    GoalAssetSizeResponse result = apiInstance.getGoalAssetSizes(goalId, clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getGoalAssetSizes");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "8d97c85c-8cbf-4ac1-a5df-f9d2bb6a77e0";

var clientId = "b4c033db-9d05-4a33-8e28-40650d454487";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getGoalAssetSizes(goalId, clientId, opts, callback);

Example Response

[
    {
      "date": "2018-02-03",
      "value": 20000,
      "additions": 0
    },
    {
      "date": "2018-02-04",
      "value": 24500,
      "additions": 500
    }
]

Get a list of asset sizes per date for a goal for a specified client. Asset size records are created at a portfolio level and aggregated to yield the goal asset sizes. Goal asset sizes are calculated by applying the goal account weights to the portfolio asset sizes of the portfolios below the accounts contributing to the goal. The goal account weights are based on the account allocation weights multiplied by the allocation composition weights for each account contributing to the goal. The unique goal_id must be provided. To obtain the appropriate goal_id, use the GET /goal endpoint to view all goals defined for your firm. A unique client_id must also be provided to return the asset size data as it relates to a specific client. To obtain the appropriate client_id, use the GET /client endpoint to view all clients defined for your firm. The endpoint returns a date, an amount value, and the funds added to the goal since the last asset size date, usually via deposit. Note that goal asset sizes will generally be estimates meant to be indicative of goal growth but may vary slightly from the asset sizes of the portfolios associated with the goal.

HTTP REQUEST

GET /goal/{goal_id}/asset_size?client_id={client_id}

ARGUMENTS

Parameter Type Required Description
client_id UUID required Id of the client subscribed to the goal
get_latest boolean optional Retrieve only the latest asset size. Defaults to false if not set
sort_type string optional Sort the asset sizes by D Daily, M Monthly, Q Quarterly, Y Yearly. Defaults to D Daily if not set. Must be capital letters
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
date date Date for this asset size record
value double Monetary value of the goal on the particular date
additions double Amount added to the goal in all of the client’s accounts on the particular date

List goal holdings

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal/7960419c-c098-4450-8cc5-866b7385230b/holding?client_id=b4c033db-9d05-4a33-8e28-40650d454487"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = '7960419c-c098-4450-8cc5-866b7385230b'
client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

try:
    # List goal holdings
    api_response = api_instance.get_goal_holdings(goal_id, client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goal_holdings: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = '7960419c-c098-4450-8cc5-866b7385230b'

client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

begin
  #List goal holdings
  result = api_instance.get_goal_holdings(goal_id, client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goal_holdings: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("7960419c-c098-4450-8cc5-866b7385230b");
UUID clientId = new UUID("b4c033db-9d05-4a33-8e28-40650d454487");
try {
    GoalHoldingsResponse result = apiInstance.getGoalHoldings(goalId, clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getGoalHoldings");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "7960419c-c098-4450-8cc5-866b7385230b";
var clientId = "b4c033db-9d05-4a33-8e28-40650d454487";

var opts = {};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getGoalHoldings(goalId, clientId, opts, callback);

Example Response

[
  {
    "date": "2018-02-03",
    "security_id": "29c3f995-bd45-4346-aea2-fd4476568d4c",
    "weight": 10,
    "amount": 2000,
    "shares": 20
  },
  {
    "date": "2018-02-03",
    "security_id": "89da9660-3efe-4694-b1a7-0958a4f72f0e",
    "weight": 2,
    "amount": 400,
    "shares": 40
  },
  {
    "date": "2018-02-03",
    "security_id": "8f7de7e6-3b32-42ff-97a4-d1260811b099",
    "weight": 30,
    "amount": 6000,
    "shares": 6
  },
  {
    "date": "2018-02-03",
    "security_id": "b2870d61-d6e0-4a94-9c1e-7a064af13eca",
    "weight": 30,
    "amount": 6000,
    "shares": 60
  },
  {
    "date": "2018-02-03",
    "security_id": "dd3e251e-90e2-4e2d-9f3a-4675be5b172f",
    "weight": 28,
    "amount": 5600,
    "shares": 50
  }
]

Get the information for all the securities that are currently being held in portfolios associated with a particular goal. Holding records are created at a portfolio level and used to calculate the holdings of the goal. Goal holdings are calculated by applying the goal account weights to the portfolio holdings of the portfolios below the accounts contributing to the goal. The goal account weights are based on the account allocation] weights multiplied by the allocation composition] weights for each account contributing to the goal. Must provide the unique goal_id. To obtain the appropriate goal_id, use the GET /goal endpoint to view all goals defined for your firm. Option to restrict was is returned by specifying a date range, obtaining the latest holdings, or only retrieving holdings of certain size(s). Endpoint returns the security_id, the security amount, the security weight and the date of the record for all securities the client holds.

HTTP REQUEST

GET /goal/{goal_id}/holding?client_id={client_id}

ARGUMENTS

Parameter Type Required Description
client_id UUID required Id of the client subscribed to the goal
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
date date Date for the security holding
security_id UUID The id for the security included in the holding record
weight double The weight of the security as a percentage of the client goal’s total monetary value; ex. 20 representing 20%
amount double Monetary value of the shares in the holding record
shares double Number of shares in the holding record

List goal transactions

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
    "https://api.hydrogenplatform.com/nucleus/v1/goal/7960419c-c098-4450-8cc5-866b7385230b/transaction?client_id=b4c033db-9d05-4a33-8e28-40650d454487"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))
goal_id = '7960419c-c098-4450-8cc5-866b7385230b'
client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

try:
    # List goal transactions
    api_response = api_instance.get_goal_transactions(goal_id, client_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goal_transactions: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

goal_id = '7960419c-c098-4450-8cc5-866b7385230b'

client_id = 'b4c033db-9d05-4a33-8e28-40650d454487'

begin
  #List goal transactions
  result = api_instance.get_goal_transactions(goal_id, client_id)
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goal_transactions: #{e}"
end
NucleusApi apiInstance = new NucleusApi();
UUID goalId = new UUID("7960419c-c098-4450-8cc5-866b7385230b");
UUID clientId = new UUID("b4c033db-9d05-4a33-8e28-40650d454487");
try {
    GoalTransactionsResponse result = apiInstance.getGoalTransactions(goalId, clientId);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling NucleusApi#getGoalTransactions");
    e.printStackTrace();
}
var apiInstance = new atom_api.NucleusApi();

var goalId = "7960419c-c098-4450-8cc5-866b7385230b";

var clientId = "b4c033db-9d05-4a33-8e28-40650d454487";

var opts = {'page': 0};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.getGoalTransactions(goalId, clientId, opts, callback);

Example Response

{
  "content": [
    {
        "id": "5736e6f7-5e12-448e-830c-c1f2b9317d48",
        "create_date": "2018-02-07T19:29:37.000+0000",
        "update_date": "2018-02-012T09:00:00.000+0000",
        "date": "2018-01-31",
        "is_read": true,
        "portfolio_id": "b4c033db-9d05-4a33-8e28-40650d454487",
        "model_id": "4b61f78e-d80e-452d-8201-b1adb87f5bb4",
        "price": 432.2,
        "quantity": 0.5,
        "security_id": "cf9de92f-1c59-4188-93af-d7d5cefd0644",
        "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386"
    },
    {
        "id": "44842cc6-37e5-44de-a799-f5c869a80726",
        "create_date": "2017-08-02T04:30:25",
        "update_date": "2017-11-18T09:00:00",
        "date": "2018-01-31",
        "is_read": true,
        "portfolio_id": "fad85772-ded2-4f12-90f7-28e68afcac6f",
        "model_id": "72ebcdfa-70c7-427b-aebb-0df000b3a0a0",
        "price": 132.2,
        "quantity": 4,
        "security_id": "6d413c-f195-4b83-b101-f3d65da5a637",
        "transaction_code_id": "f5af397b-7d22-433f-b01e-8202184a6386"
    }
  ],
  "total_pages": 1,
  "total_elements": 2,
  "last": true,
  "sort": [
      {
        "direction": "DESC",
        "property": "id",
        "ignore_case": false,
        "null_handling": "NATIVE",
        "descending": true,
        "ascending": false
      }
  ],
  "first": true,
  "number_of_elements": 2,
  "size": 25,
  "number": 2
}

Get the information for all transactions under portfolios associated with a particular goal. Transactions represent buy or sell orders for securities. Transaction records are created at the portfolio level and all transactions for each portfolio below an account contributing to the goal are returned to show the transaction activity for the goal. Must provide the unique goal_id. To obtain the appropriate goal_id, use the GET /goal endpoint to view all goals defined for your firm. Endpoint returns details such as the portfolio_transaction_id, the date for the transaction, the transaction_code_id, the quantity of security, the price of the security, the portfolio_id, the account_id, an indicator for whether or not the transaction has been read, etc. for all transactions. See the Order section.

HTTP REQUEST

GET /goal/{goal_id}/transaction?client_id={client_id}

ARGUMENTS

Parameter Type Required Description
client_id UUID required Id of the client subscribed to the goal
start_date date optional Start date for the data. Defaults to the first date if not set
end_date date optional End date for the data. Defaults to the last date if not set

RESPONSE

Field Type Description
id UUID The id for the transaction record
date date Date of the transaction record
is_read boolean Indicator to show whether or not the transaction has been read. Defaults to true which indicates it has been read.
portfolio_id UUID The id of the portfolio that the transaction falls under
model_id UUID The id of the model to which the portfolio that the transaction falls under subscribes
price double Price for the security included in the transaction at which is was sold or purchased
quantity double Quantity of shares of the security purchased
security_id UUID The id of the security included in the transaction
transaction_code_id integer The id referring to the transaction codes defined by your firm
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

Goal Track

Goal track is used to store the current status of a goal at a point in time and track the progress over time. The status information stored includes the goal amount, the accumulation and decumulation horizons, the accounts participating in the goal, the current goal balance, and the metrics for whether or not the goal will be achieved such as if the goal is on track to be met. The metrics for whether or not the goal will be achieved can be obtained using the Proton API tool, but this is not required.

Field Type Description
id UUID The id for the goal track record
goal_id UUID The id of a goal to which the goal track record pertains
client_id UUID The id of a client to whom the goal for the goal track record belongs
goal_amount double Target amount for the goal
accumulation_horizon double The time horizon of the goal during the accumulation phase, in years
decumulation_horizon double The time horizon of the goal during the decumulation phase, in years
accounts array List of accounts linked to the goal
      account_id UUID The id of the account linked to the goal
current_investment double The current amount invested toward the goal
on_track boolean Indicator for whether or not the goal is on track to be met. true indicates it is on track (no default)
progress double The goal progress percentage as a decimal
goal_probability double The probability of achieving the goal with the client’s given investments
goal_achievement_score double Probability of achieving the goal in relation to the confidence target of a simulation
projection_balance double The projected balance of the goal
projection_date date The date of the projected balance of the goal
status_time_stamp datetime Date and time to which this goal track record applies, defaults to the current timestamp
metadata map Custom information associated with the goal track record in the format key:value
See Metadata
secondary_id string Alternate id that can be used to identify the object such as an internal id
create_date timestamp Timestamp for the date and time that the record was created
update_date timestamp Timestamp for the date and time that the record was last updated

List all goal track records

Example Request

curl -X GET -H "Authorization: Bearer ac6b8213-2a77-4ecc-89fd-68c9f2aff256" \
  "https://api.hydrogenplatform.com/nucleus/v1/goal_track"
api_instance = atom_api.NucleusApi(atom_api.ApiClient(configuration))

try:
    # List all goal track records
    api_response = api_instance.get_goal_track_records()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NucleusApi->get_goal_track_records: %s\n" % e)
api_instance = AtomApi::NucleusApi.new

begin
  #List all goal track records
  result = api_instance.get_goal_track_records()
  p result
rescue AtomApi::ApiError => e
  puts "Exception when calling NucleusApi->get_goal_track_records: #{e}"
end
NucleusApi apiInstance = new NucleusApi();