NAV
curl JavaScript Node.JS Python PHP
API reference

Overview

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

The Glassboard API is organized around REST. Our API has predictable resource-oriented URLs, accepts and returns JSON-encoded request and responses bodies, and uses standard HTTP response codes, authentication, and verbs.

The Glassboard API may differ for every account as we release new versions and tailor functionality based on customer needs. The API specification below is universally available.

Cross-Origin Resource Sharing

This API features Cross-Origin Resource Sharing (CORS) implemented in compliance with W3C spec. And that allows cross-domain communication from the browser.

All responses have a wildcard same-origin which makes them completely public and accessible to everyone, including any code on any site.

Request Basics

Headers

Currently, this API only communicates with JSON, so in some situations you may need to set Accept or Content-Type to application/json. Glassboard Technology enables platforms and applications for a variety of organizations and users. To ensure an orderly separation of resource ownership this API requires a tenant identification in all requests. In the request header, set the value x-tenant-id to your id. All requests without this value will be rejected with a 401 response.

Terms of service Email: API Support Web: API Support

Authentication

The Client Credentials grant type is used by clients to obtain an access token outside of the context of a user. This is typically used by clients to access resources about themselves rather than to access a user's resources. The process to obtain a token:

  1. The Client Application sends an request to the Authorization Endpoing (/oauth2/token) with the client id and client secret in the request body. This request may include requested scopes.
  2. In the response, the Authorization Endpoint sends an Access Token (JWT).
  3. The Client Application uses the Access Token to call Resource Endpoints.

The Authorization Code grant type is used by confidential and public clients to exchange an authorization code for an access token. After the user returns to the client via the redirect URL, the application will get the authorization code from the URL and use it to request an access token.

  1. The Client initiates the flow by redirecting the User Agent of the Resource Owner to the Authorization Server. The Client includes its Client ID, requested scopes, and the redirect URI.
  2. Resource Owner authorizes the Client by granting permissions requested by the Client.
  3. Authorization Server redirects the User Agent back to the Client (using redirect URI from point 1). The redirect URI includes a temporary Authorization Code (as a query param).
  4. Client requests an Access Token from the Authorization Server. The request includes Client ID, Client Secret, and Authorization Code received in the previous step.
  5. If everything is valid, the Authorization Server returns Access Token and, optionally, a Refresh Token.
  6. The client uses the Access Token to call the Resource Server on behalf of the Resource Owner.

- Flow: clientCredentials

- Token URL = /oauth2/token

Scope Scope Description
read Grant read-only access to all your data except for the account and user info
write Grant write-only access to all your data except for the account and user info

- Flow: authorizationCode - Authorization URL = /auth/realms/gbt/.well-known/openid-configuration - Token URL = /auth/realms/gbt/.well-known/openid-configuration

Scope Scope Description

Endpoints

Assets

Assets represent the investment vehicle for a deal. An asset can take one of many forms, such as, shares of common stock in a company, real estate, crypocurrency, or even fractional ownership in a private jet. The object specification is general enough to include a complete description of the asset, supporting documentation, and profiles of the key team members.

Add Documents to an Asset

Code samples

# You can also use wget
curl -X PUT /assets/documents-upload/{assetId} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/documents-upload/{assetId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "file": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/documents-upload/{assetId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/assets/documents-upload/{assetId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'multipart/form-data',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/assets/documents-upload/{assetId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Upload documents for the specified asset

Endpoint

PUT /assets/documents-upload/{assetId} Try it out

Body parameter

file: string

Parameters

Parameter In Type Required Description
assetId path string true none
body body object true Request body for multipart/form-data based file upload
» file body string(binary) false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

Search Assets

Code samples

# You can also use wget
curl -X POST /assets/search \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/search',
  method: 'post',

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

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

};

fetch('/assets/search',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/assets/search', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/assets/search', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Search assets

Endpoint

POST /assets/search Try it out

Body parameter

{}

Parameters

Parameter In Type Required Description
body body object false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "dealId": "string",
      "type": "COMPANY",
      "subType": "string",
      "unitCount": 0,
      "allocationAmount": 0,
      "name": "string",
      "sector": "string",
      "primaryContact": {},
      "companyMarketSector": "COMMUNICATION_SERVICES",
      "description": "string",
      "size": "string",
      "category": "string",
      "advisors": "string",
      "details": [
        {}
      ],
      "properties": [
        {}
      ],
      "assetUrl": "string",
      "appraisedValue": 0,
      "fractionalOwnershipAmount": 0,
      "artist": {},
      "contact": {},
      "funding": {},
      "team": [
        {
          "name": "string",
          "role": "string",
          "linkedInUrl": "string",
          "image": "string"
        }
      ],
      "revenueHistory": [
        "string"
      ],
      "costsHistory": [
        "string"
      ],
      "invitedOrganizers": [
        "string"
      ],
      "files": [
        "string"
      ],
      "images": [
        "string"
      ],
      "video": "string",
      "pitchDoc": "string",
      "videoURL": "string",
      "isPublic": true,
      "logo": "string",
      "banner": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request AssetsList

Delete an Asset Document

Code samples

# You can also use wget
curl -X DELETE /assets/{assetId}/delete-documents/{fileId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/{assetId}/delete-documents/{fileId}',
  method: 'delete',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/{assetId}/delete-documents/{fileId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/assets/{assetId}/delete-documents/{fileId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/assets/{assetId}/delete-documents/{fileId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Delete a Document for an Asset

Endpoint

DELETE /assets/{assetId}/delete-documents/{fileId} Try it out

Parameters

Parameter In Type Required Description
assetId path string true none
fileId path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

Update Documents for an Asset

Code samples

# You can also use wget
curl -X PUT /assets/{assetId}/update-documents/{fileId} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/{assetId}/update-documents/{fileId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "file": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/{assetId}/update-documents/{fileId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('/assets/{assetId}/update-documents/{fileId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'multipart/form-data',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/assets/{assetId}/update-documents/{fileId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update documents on an asset

Endpoint

PUT /assets/{assetId}/update-documents/{fileId} Try it out

Body parameter

file: string

Parameters

Parameter In Type Required Description
assetId path string true none
fileId path string true none
body body object true Request body for multipart/form-data based file upload
» file body string(binary) false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

Update an Asset by Id

Code samples

# You can also use wget
curl -X PUT /assets/{assetId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/{assetId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/{assetId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/assets/{assetId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/assets/{assetId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update an asset for the current user

Endpoint

PUT /assets/{assetId} Try it out

Body parameter

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
assetId path string true none
body body AssetPartial false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

Get an Asset by Id

Code samples

# You can also use wget
curl -X GET /assets/{assetId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/{assetId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/{assetId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/assets/{assetId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/assets/{assetId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get an Asset for the current user by Id

Endpoint

GET /assets/{assetId} Try it out

Parameters

Parameter In Type Required Description
assetId path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

Delete an Asset

Code samples

# You can also use wget
curl -X DELETE /assets/{assetId} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets/{assetId}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/assets/{assetId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/assets/{assetId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/assets/{assetId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Delete an asset for the current user

Endpoint

DELETE /assets/{assetId} Try it out

Parameters

Parameter In Type Required Description
assetId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create an Asset

Code samples

# You can also use wget
curl -X POST /assets \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/assets', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/assets', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create an asset for the current user

Endpoint

POST /assets Try it out

Body parameter

{
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
body body NewAsset false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "type": "COMPANY",
  "subType": "string",
  "unitCount": 0,
  "allocationAmount": 0,
  "name": "string",
  "sector": "string",
  "primaryContact": {},
  "companyMarketSector": "COMMUNICATION_SERVICES",
  "description": "string",
  "size": "string",
  "category": "string",
  "advisors": "string",
  "details": [
    {}
  ],
  "properties": [
    {}
  ],
  "assetUrl": "string",
  "appraisedValue": 0,
  "fractionalOwnershipAmount": 0,
  "artist": {},
  "contact": {},
  "funding": {},
  "team": [
    {
      "name": "string",
      "role": "string",
      "linkedInUrl": "string",
      "image": "string"
    }
  ],
  "revenueHistory": [
    "string"
  ],
  "costsHistory": [
    "string"
  ],
  "invitedOrganizers": [
    "string"
  ],
  "files": [
    "string"
  ],
  "images": [
    "string"
  ],
  "video": "string",
  "pitchDoc": "string",
  "videoURL": "string",
  "isPublic": true,
  "logo": "string",
  "banner": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Asset

List Assets

Code samples

# You can also use wget
curl -X GET /assets \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/assets',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/assets',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/assets', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/assets', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List current user's assets to which the authentication method has access.

Endpoint

GET /assets Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "dealId": "string",
      "type": "COMPANY",
      "subType": "string",
      "unitCount": 0,
      "allocationAmount": 0,
      "name": "string",
      "sector": "string",
      "primaryContact": {},
      "companyMarketSector": "COMMUNICATION_SERVICES",
      "description": "string",
      "size": "string",
      "category": "string",
      "advisors": "string",
      "details": [
        {}
      ],
      "properties": [
        {}
      ],
      "assetUrl": "string",
      "appraisedValue": 0,
      "fractionalOwnershipAmount": 0,
      "artist": {},
      "contact": {},
      "funding": {},
      "team": [
        {
          "name": "string",
          "role": "string",
          "linkedInUrl": "string",
          "image": "string"
        }
      ],
      "revenueHistory": [
        "string"
      ],
      "costsHistory": [
        "string"
      ],
      "invitedOrganizers": [
        "string"
      ],
      "files": [
        "string"
      ],
      "images": [
        "string"
      ],
      "video": "string",
      "pitchDoc": "string",
      "videoURL": "string",
      "isPublic": true,
      "logo": "string",
      "banner": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request AssetsList

Banking

Everything about banking

Create a ACH Banking Beneficiary

Code samples

# You can also use wget
curl -X POST /banking/ACHBeneficiaries \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/ACHBeneficiaries',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "email": "string",
  "phone": "string",
  "nameOnAccount": "string",
  "accountNumber": "string",
  "routingNumber": "string",
  "accountType": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/ACHBeneficiaries',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/banking/ACHBeneficiaries', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/banking/ACHBeneficiaries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a ACH Banking Beneficiary with the supplied data

Endpoint

POST /banking/ACHBeneficiaries Try it out

Body parameter

{
  "email": "string",
  "phone": "string",
  "nameOnAccount": "string",
  "accountNumber": "string",
  "routingNumber": "string",
  "accountType": "string"
}

Parameters

Parameter In Type Required Description
body body object false none
» email body string false none
» phone body string false none
» nameOnAccount body string true none
» accountNumber body string true none
» routingNumber body string true none
» accountType body string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "phone": "string",
  "email": "string",
  "serviceObjectId": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "providerMeta": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankingBeneficiary

Create an ACH Transaction

Code samples

# You can also use wget
curl -X POST /banking/account/{accountId}/ach \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/account/{accountId}/ach',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "accountId": "string",
  "subAccountId": "string",
  "direction": "CREDIT",
  "amount": 0.01
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/account/{accountId}/ach',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/banking/account/{accountId}/ach', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/banking/account/{accountId}/ach', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create an ACH Transaction with the supplied data

Endpoint

POST /banking/account/{accountId}/ach Try it out

Body parameter

{
  "accountId": "string",
  "subAccountId": "string",
  "direction": "CREDIT",
  "amount": 0.01
}

Parameters

Parameter In Type Required Description
accountId path string true none
body body object true none
» accountId body string true none
» subAccountId body string true none
» direction body string true none
» amount body number false none

Enumerated Values

Parameter Value
» direction CREDIT
» direction DEBIT

Example responses

204 Response

true

Responses

Status Meaning Description Schema
204 No Content Expected response to a valid request boolean

List Transactions from the Bank Account

Code samples

# You can also use wget
curl -X GET /banking/account/{bankAccountId}/transactions \
  -H 'Accept: application/json' \
  -H 'x-tenant-id: string' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/account/{bankAccountId}/transactions',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/account/{bankAccountId}/transactions',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'x-tenant-id': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/banking/account/{bankAccountId}/transactions', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'x-tenant-id' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/banking/account/{bankAccountId}/transactions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns the Transaction Listing from the Bank Account

Endpoint

GET /banking/account/{bankAccountId}/transactions Try it out

Parameters

Parameter In Type Required Description
bankAccountId path string true none
x-tenant-id header string true Your Tenant ID

Example responses

Example Transaction Listing

[
  {
    "amount": "25000.00",
    "date": "2021-07-15",
    "desc": "WIRE IN JOHN DOE",
    "book_id": null,
    "type": "deposit",
    "summary": "",
    "balance": "25000.00",
    "id": "ctx_1k8s0v02e4bytvzg",
    "ach_id": null,
    "fingerprint": "7c0a02c8cd8fe7dea1da389ced317ffb4b6dfd7c",
    "check_number": null
  }
]

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Inline

Response Schema

Get Bank Account by ID

Code samples

# You can also use wget
curl -X GET /banking/account/{accountId} \
  -H 'Accept: application/json' \
  -H 'x-tenant-id: string' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/account/{accountId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/account/{accountId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'x-tenant-id': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/banking/account/{accountId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'x-tenant-id' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/banking/account/{accountId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get Bank Account by Id

Endpoint

GET /banking/account/{accountId} Try it out

Parameters

Parameter In Type Required Description
accountId path string true none
x-tenant-id header string true Your Tenant ID

Example responses

Example Get Bank Account By Id

{
  "id": "d203b77d-c860-491c-a9fa-bf4110e4e8a7",
  "status": "OPEN",
  "accountNumber": "111111111",
  "routingNumber": "912312312",
  "accountName": "Test Account",
  "bankName": "The Provident Bank",
  "currentBalance": 10000.11,
  "availableBalance": 2000.85,
  "bankContact": {
    "name": "John Doe",
    "phone": "555-555-5555",
    "email": "john@test.com"
  },
  "swiftCode": "PRDIUS33",
  "bankAddress": "5 Market Street Amesbury, MA 01913",
  "createdAt": "2021-03-29T14:45:20.140Z",
  "updatedAt": "2021-03-29T14:45:30.430Z"
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankAccountExcluding_providerMeta_

Create a Bank Account

Code samples

# You can also use wget
curl -X POST /banking/account \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/account',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "ein": "12-3456789",
  "entityName": "Example LLC"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/account',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/banking/account', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/banking/account', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a Bank Account with the supplied data

Endpoint

POST /banking/account Try it out

Body parameter

Example Bank Account Creation Request

{
  "ein": "12-3456789",
  "entityName": "Example LLC"
}

Parameters

Parameter In Type Required Description
body body object true none
» ein body string true none
» entityName body string true none

Example responses

Example Bank Account Creation Response

{
  "id": "d203b77d-c860-491c-a9fa-bf4110e4e8a7",
  "status": "PENDING",
  "accountNumber": null,
  "routingNumber": null,
  "accountName": null,
  "bankName": null,
  "bankContact": null,
  "swiftCode": null,
  "bankAddress": null,
  "createdAt": "2021-03-29T14:45:20.140Z",
  "updatedAt": "2021-03-29T14:45:30.430Z"
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankAccount

List Bank Accounts

Code samples

# You can also use wget
curl -X GET /banking/account \
  -H 'Accept: application/json' \
  -H 'x-tenant-id: string' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/account',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/account',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'x-tenant-id': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/banking/account', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'x-tenant-id' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/banking/account', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List Bank Accounts for the current user

Endpoint

GET /banking/account Try it out

Parameters

Parameter In Type Required Description
perPage query integer false none
page query integer false none
x-tenant-id header string true Your Tenant ID

Example responses

Example Formation Request for EIN

[
  {
    "id": "d203b77d-c860-491c-a9fa-bf4110e4e8a7",
    "status": "OPEN",
    "accountNumber": "111111111",
    "routingNumber": "912312312",
    "accountName": "Test Account",
    "bankName": "The Provident Bank"
  }
]

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request List

Get Banking Beneficiary by Id

Code samples

# You can also use wget
curl -X GET /banking/beneficiaries/{beneficiaryId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/beneficiaries/{beneficiaryId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/beneficiaries/{beneficiaryId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/banking/beneficiaries/{beneficiaryId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/banking/beneficiaries/{beneficiaryId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get Banking Beneficiaries with the provided Id

Endpoint

GET /banking/beneficiaries/{beneficiaryId} Try it out

Parameters

Parameter In Type Required Description
id path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "phone": "string",
  "email": "string",
  "serviceObjectId": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "providerMeta": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankingBeneficiary

Create a Banking Beneficiary

Code samples

# You can also use wget
curl -X POST /banking/beneficiaries \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/beneficiaries',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "email": "string",
  "phone": "string",
  "routingNumber": "string",
  "accountNumber": "string",
  "bankName": "string",
  "bankAddress": {},
  "addressOnAccount": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/beneficiaries',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/banking/beneficiaries', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/banking/beneficiaries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a Banking Beneficiary with the supplied data

Endpoint

POST /banking/beneficiaries Try it out

Body parameter

{
  "name": "string",
  "email": "string",
  "phone": "string",
  "routingNumber": "string",
  "accountNumber": "string",
  "bankName": "string",
  "bankAddress": {},
  "addressOnAccount": {}
}

Parameters

Parameter In Type Required Description
body body object false none
» name body string true none
» email body string false none
» phone body string false none
» routingNumber body string true none
» accountNumber body string true none
» bankName body string true none
» bankAddress body object true none
» addressOnAccount body object true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "phone": "string",
  "email": "string",
  "serviceObjectId": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "providerMeta": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankingBeneficiary

List Banking Beneficiaries

Code samples

# You can also use wget
curl -X GET /banking/beneficiaries \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/banking/beneficiaries',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/banking/beneficiaries',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/banking/beneficiaries', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/banking/beneficiaries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List Banking Beneficiaries for the current user

Endpoint

GET /banking/beneficiaries Try it out

Parameters

Parameter In Type Required Description
perPage query integer false none
page query integer false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "name": "string",
      "phone": "string",
      "email": "string",
      "serviceObjectId": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "providerMeta": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request BankingBeneficiariesList

Closes

A Close groups Subscriptions together for completion of the investment process. A close can represent the close of the entire deal or just a subset of investments (i.e. a tranche).

Sign a Close as the Fund Manager

Code samples

# You can also use wget
curl -X POST /closes/{closeId}/fund-manager-sign \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes/{closeId}/fund-manager-sign',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "fundManagerSignature": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/closes/{closeId}/fund-manager-sign',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/closes/{closeId}/fund-manager-sign', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/closes/{closeId}/fund-manager-sign', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Signs the Close documents as the Fund Manager

Endpoint

POST /closes/{closeId}/fund-manager-sign Try it out

Body parameter

{
  "fundManagerSignature": "string"
}

Parameters

Parameter In Type Required Description
closeId path string true none
body body object false none
» fundManagerSignature body string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Close

Update Close by ID

Code samples

# You can also use wget
curl -X PUT /closes/{closeId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes/{closeId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/closes/{closeId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/closes/{closeId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/closes/{closeId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update a close with the supplied information

Endpoint

PUT /closes/{closeId} Try it out

Body parameter

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}

Parameters

Parameter In Type Required Description
closeId path string true none
body body ClosePartial false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Close

Get a Close by ID

Code samples

# You can also use wget
curl -X GET /closes/{closeId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes/{closeId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/closes/{closeId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/closes/{closeId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/closes/{closeId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get Close by ID

Endpoint

GET /closes/{closeId} Try it out

Parameters

Parameter In Type Required Description
closeId path string true none
filter query object false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Close

Create a Close

Code samples

# You can also use wget
curl -X POST /closes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes',
  method: 'post',

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

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

};

fetch('/closes',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/closes', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/closes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create an Close object for the specified deal

Endpoint

POST /closes Try it out

Body parameter

null

Parameters

Parameter In Type Required Description
body body any false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "organizerSignature": "string",
  "fundManagerSignature": "string",
  "files": [
    "string"
  ],
  "dateClosed": "2019-08-24T14:15:22Z",
  "fundsWiredDate": "2019-08-24T14:15:22Z",
  "readyToCounterSign": true,
  "fundManagerSigned": true,
  "blueSky": {},
  "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
  "statement": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "sequence": 0,
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "entityId": "string",
  "dealId": "string",
  "subscriptions": [
    "string"
  ],
  "isDeleted": true
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Close

List closes

Code samples

# You can also use wget
curl -X GET /closes \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/closes',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/closes', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/closes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List closes to which the authentication method has access.

Endpoint

GET /closes Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none
filter query Close.Filter false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "organizerSignature": "string",
      "fundManagerSignature": "string",
      "files": [
        "string"
      ],
      "dateClosed": "2019-08-24T14:15:22Z",
      "fundsWiredDate": "2019-08-24T14:15:22Z",
      "readyToCounterSign": true,
      "fundManagerSigned": true,
      "blueSky": {},
      "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
      "statement": {},
      "createdAt": "2019-08-24T14:15:22Z",
      "sequence": 0,
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "entityId": "string",
      "dealId": "string",
      "subscriptions": [
        "string"
      ],
      "isDeleted": true
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request ClosesList
400 Bad Request Invalid Request None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
default Default none None

Get Closes by Deal Id

Code samples

# You can also use wget
curl -X GET /closes-by-deal/{dealId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/closes-by-deal/{dealId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/closes-by-deal/{dealId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/closes-by-deal/{dealId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/closes-by-deal/{dealId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get the Close objects associated with a Deal by Deal Id

Endpoint

GET /closes-by-deal/{dealId} Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none
dealId path string true none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "organizerSignature": "string",
      "fundManagerSignature": "string",
      "files": [
        "string"
      ],
      "dateClosed": "2019-08-24T14:15:22Z",
      "fundsWiredDate": "2019-08-24T14:15:22Z",
      "readyToCounterSign": true,
      "fundManagerSigned": true,
      "blueSky": {},
      "purchaseDocsSignedDate": "2019-08-24T14:15:22Z",
      "statement": {},
      "createdAt": "2019-08-24T14:15:22Z",
      "sequence": 0,
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "entityId": "string",
      "dealId": "string",
      "subscriptions": [
        "string"
      ],
      "isDeleted": true
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request ClosesList

Companies

This object can store general information about a Company for a variety of purposes. Some examples include fund managers, portfolio companies, or registered agents.

Search for a Company

Code samples

# You can also use wget
curl -X POST /companies/search \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies/search',
  method: 'post',

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

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

};

fetch('/companies/search',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/companies/search', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/companies/search', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Search Companies for the current user by the supplied paramters

Endpoint

POST /companies/search Try it out

Body parameter

{}

Parameters

Parameter In Type Required Description
body body object false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "name": "string",
      "website": "string",
      "email": "string",
      "type": "MASTER_ENTITY",
      "entityType": "string",
      "phone": "string",
      "seriesNumber": 0,
      "stateOfFormation": "string",
      "address": {},
      "ownerId": "string",
      "tenantId": "string",
      "arbitrationCity": "string",
      "arbitrationState": "string",
      "primaryContact": {},
      "taxContact": {},
      "legalIncOrder": {},
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "entitytype": "LLC",
      "typeOfBusiness": "string",
      "typeOfBusinessActivity": "string",
      "professionalEntity": true,
      "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
      "individualOrBusiness": "Individual",
      "individual": {
        "firstName": "string",
        "lastName": "string",
        "memberAddress": "string",
        "isManager": true,
        "percentageOwnership": 0,
        "capitalContribution": 0
      },
      "business": {
        "businessName": "string",
        "address": "string",
        "isManager": true,
        "percentageOwnership": 0,
        "capitalContribution": 0
      },
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request CompaniesList

Update a Company

Code samples

# You can also use wget
curl -X PUT /companies/{companyId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies/{companyId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/companies/{companyId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/companies/{companyId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/companies/{companyId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update the specified Company with supplied data

Endpoint

PUT /companies/{companyId} Try it out

Body parameter

{
  "id": "string",
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
companyId path string true none
body body CompanyPartial false none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Company

Get a Company by Id

Code samples

# You can also use wget
curl -X GET /companies/{companyId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies/{companyId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/companies/{companyId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/companies/{companyId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/companies/{companyId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get a Company matching the supplied Id

Endpoint

GET /companies/{companyId} Try it out

Parameters

Parameter In Type Required Description
companyId path string true none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Company

Delete a Company

Code samples

# You can also use wget
curl -X DELETE /companies/{companyId} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies/{companyId}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/companies/{companyId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/companies/{companyId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/companies/{companyId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Delete the Specified Company

Endpoint

DELETE /companies/{companyId} Try it out

Parameters

Parameter In Type Required Description
companyId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create a Company

Code samples

# You can also use wget
curl -X POST /companies \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/companies',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/companies', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/companies', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a Company Object from the supplied data

Endpoint

POST /companies Try it out

Body parameter

{
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
body body NewCompany false none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "website": "string",
  "email": "string",
  "type": "MASTER_ENTITY",
  "entityType": "string",
  "phone": "string",
  "seriesNumber": 0,
  "stateOfFormation": "string",
  "address": {},
  "ownerId": "string",
  "tenantId": "string",
  "arbitrationCity": "string",
  "arbitrationState": "string",
  "primaryContact": {},
  "taxContact": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "entitytype": "LLC",
  "typeOfBusiness": "string",
  "typeOfBusinessActivity": "string",
  "professionalEntity": true,
  "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
  "individualOrBusiness": "Individual",
  "individual": {
    "firstName": "string",
    "lastName": "string",
    "memberAddress": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "business": {
    "businessName": "string",
    "address": "string",
    "isManager": true,
    "percentageOwnership": 0,
    "capitalContribution": 0
  },
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Company

List Companies

Code samples

# You can also use wget
curl -X GET /companies \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/companies',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/companies',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/companies', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/companies', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get a list of Companies for the current user

Endpoint

GET /companies Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none
filter query Company.Filter false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "name": "string",
      "website": "string",
      "email": "string",
      "type": "MASTER_ENTITY",
      "entityType": "string",
      "phone": "string",
      "seriesNumber": 0,
      "stateOfFormation": "string",
      "address": {},
      "ownerId": "string",
      "tenantId": "string",
      "arbitrationCity": "string",
      "arbitrationState": "string",
      "primaryContact": {},
      "taxContact": {},
      "legalIncOrder": {},
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "entitytype": "LLC",
      "typeOfBusiness": "string",
      "typeOfBusinessActivity": "string",
      "professionalEntity": true,
      "howWillBeBusinessManaged": "Solely by the owner(s) (Member-managed)",
      "individualOrBusiness": "Individual",
      "individual": {
        "firstName": "string",
        "lastName": "string",
        "memberAddress": "string",
        "isManager": true,
        "percentageOwnership": 0,
        "capitalContribution": 0
      },
      "business": {
        "businessName": "string",
        "address": "string",
        "isManager": true,
        "percentageOwnership": 0,
        "capitalContribution": 0
      },
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request CompaniesList

Deals

A deal is a fundamental object that represents the opportunity into which user make an investment.

DealsController.charts

Code samples

# You can also use wget
curl -X GET /deals/charts \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/charts',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/charts',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/deals/charts', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/deals/charts', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Endpoint

GET /deals/charts Try it out

Parameters

Parameter In Type Required Description
startDate query number false none
endDate query number false none

Example responses

200 Response

null

Responses

Status Meaning Description Schema
200 OK Deals Chart Inline

Response Schema

Search for Deals

Code samples

# You can also use wget
curl -X POST /deals/search \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/search',
  method: 'post',

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

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

};

fetch('/deals/search',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/deals/search', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/deals/search', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Search Deals for the current user

Endpoint

POST /deals/search Try it out

Body parameter

{}

Parameters

Parameter In Type Required Description
body body object false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "gbtRole": "string",
      "ownerId": "string",
      "tenantId": "string",
      "entityId": "string",
      "assetIds": [
        "string"
      ],
      "name": "string",
      "description": "string",
      "marketing": {},
      "portfolioCompanyName": "string",
      "portfolioCompanyState": "string",
      "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
      "targetRaiseAmount": 0,
      "minInvestmentAmount": 0,
      "previouslyRaisedAmount": 0,
      "securityType": "COMMON_STOCK",
      "isPublic": true,
      "disabled": true,
      "files": [
        "string"
      ],
      "organizerFiles": [
        "string"
      ],
      "estimatedCloseDate": "2019-08-24T14:15:22Z",
      "organizerCarryPercentage": 100,
      "additionalCarryRecipients": [
        {
          "individual": {
            "id": "string",
            "ownerId": "string",
            "name": "string",
            "type": "string",
            "title": "string",
            "isUSBased": true,
            "address": {},
            "phone": "string",
            "email": "string",
            "taxDetails": {},
            "dateOfBirth": "string",
            "stateOfFormation": "string",
            "countryOfFormation": "string",
            "taxIdType": "string",
            "taxId": "string",
            "passport": "string"
          },
          "carryPercentage": 0
        }
      ],
      "portfolioCompanyContact": {},
      "status": "DRAFT",
      "closes": [
        "string"
      ],
      "requireQualifiedPurchaser": true,
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "profileId": "string",
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request DealsList

Get deals by profileId

Code samples

# You can also use wget
curl -X GET /deals/{profileId}/deals-meta \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/{profileId}/deals-meta',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/{profileId}/deals-meta',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/deals/{profileId}/deals-meta', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/deals/{profileId}/deals-meta', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns deals given a specific profileId

Endpoint

GET /deals/{profileId}/deals-meta Try it out

Parameters

Parameter In Type Required Description
profileId path string true none
filter query Deal.Filter false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "gbtRole": "string",
      "ownerId": "string",
      "tenantId": "string",
      "entityId": "string",
      "assetIds": [
        "string"
      ],
      "name": "string",
      "description": "string",
      "marketing": {},
      "portfolioCompanyName": "string",
      "portfolioCompanyState": "string",
      "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
      "targetRaiseAmount": 0,
      "minInvestmentAmount": 0,
      "previouslyRaisedAmount": 0,
      "securityType": "COMMON_STOCK",
      "isPublic": true,
      "disabled": true,
      "files": [
        "string"
      ],
      "organizerFiles": [
        "string"
      ],
      "estimatedCloseDate": "2019-08-24T14:15:22Z",
      "organizerCarryPercentage": 100,
      "additionalCarryRecipients": [
        {
          "individual": {
            "id": "string",
            "ownerId": "string",
            "name": "string",
            "type": "string",
            "title": "string",
            "isUSBased": true,
            "address": {},
            "phone": "string",
            "email": "string",
            "taxDetails": {},
            "dateOfBirth": "string",
            "stateOfFormation": "string",
            "countryOfFormation": "string",
            "taxIdType": "string",
            "taxId": "string",
            "passport": "string"
          },
          "carryPercentage": 0
        }
      ],
      "portfolioCompanyContact": {},
      "status": "DRAFT",
      "closes": [
        "string"
      ],
      "requireQualifiedPurchaser": true,
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "profileId": "string",
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request DealsList

Get a close statement for a deal by dealId

Code samples

# You can also use wget
curl -X GET /deals/{dealId}/fees-statement \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/{dealId}/fees-statement',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/{dealId}/fees-statement',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/deals/{dealId}/fees-statement', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/deals/{dealId}/fees-statement', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns information regarding what costs will be associated with a deal

Endpoint

GET /deals/{dealId}/fees-statement Try it out

Parameters

Parameter In Type Required Description
dealId path string true none

Example responses

200 Response

null

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Inline

Response Schema

Update Deal Asset

Code samples

# You can also use wget
curl -X PUT /deals/{dealId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/{dealId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/{dealId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/deals/{dealId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/deals/{dealId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update a Deal with the supplied data

Endpoint

PUT /deals/{dealId} Try it out

Body parameter

{
  "id": "string",
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
dealId path string true none
body body DealPartial false none

Example responses

200 Response

{
  "id": "string",
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Deal

Get a Deal by Id

Code samples

# You can also use wget
curl -X GET /deals/{dealId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/{dealId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/{dealId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/deals/{dealId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/deals/{dealId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get a Deal by Id

Endpoint

GET /deals/{dealId} Try it out

Parameters

Parameter In Type Required Description
dealId path string true none

Example responses

200 Response

{
  "id": "string",
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Deal

Delete a Deal

Code samples

# You can also use wget
curl -X DELETE /deals/{dealId} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals/{dealId}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/deals/{dealId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/deals/{dealId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/deals/{dealId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Delete the specified deal

Endpoint

DELETE /deals/{dealId} Try it out

Parameters

Parameter In Type Required Description
dealId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create a Deal

Code samples

# You can also use wget
curl -X POST /deals \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/deals', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/deals', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a new deal for the user

Endpoint

POST /deals Try it out

Body parameter

{
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
body body NewDeal false none

Example responses

200 Response

{
  "id": "string",
  "gbtRole": "string",
  "ownerId": "string",
  "tenantId": "string",
  "entityId": "string",
  "assetIds": [
    "string"
  ],
  "name": "string",
  "description": "string",
  "marketing": {},
  "portfolioCompanyName": "string",
  "portfolioCompanyState": "string",
  "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
  "targetRaiseAmount": 0,
  "minInvestmentAmount": 0,
  "previouslyRaisedAmount": 0,
  "securityType": "COMMON_STOCK",
  "isPublic": true,
  "disabled": true,
  "files": [
    "string"
  ],
  "organizerFiles": [
    "string"
  ],
  "estimatedCloseDate": "2019-08-24T14:15:22Z",
  "organizerCarryPercentage": 100,
  "additionalCarryRecipients": [
    {
      "individual": {
        "id": "string",
        "ownerId": "string",
        "name": "string",
        "type": "string",
        "title": "string",
        "isUSBased": true,
        "address": {},
        "phone": "string",
        "email": "string",
        "taxDetails": {},
        "dateOfBirth": "string",
        "stateOfFormation": "string",
        "countryOfFormation": "string",
        "taxIdType": "string",
        "taxId": "string",
        "passport": "string"
      },
      "carryPercentage": 0
    }
  ],
  "portfolioCompanyContact": {},
  "status": "DRAFT",
  "closes": [
    "string"
  ],
  "requireQualifiedPurchaser": true,
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "profileId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Deal

List Deals

Code samples

# You can also use wget
curl -X GET /deals \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/deals',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/deals',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/deals', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/deals', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List current user's deals to which the authentication method has access.

Endpoint

GET /deals Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "gbtRole": "string",
      "ownerId": "string",
      "tenantId": "string",
      "entityId": "string",
      "assetIds": [
        "string"
      ],
      "name": "string",
      "description": "string",
      "marketing": {},
      "portfolioCompanyName": "string",
      "portfolioCompanyState": "string",
      "portfolioCompanyEntity": "LIMITED_LIABILITY_COMPANY",
      "targetRaiseAmount": 0,
      "minInvestmentAmount": 0,
      "previouslyRaisedAmount": 0,
      "securityType": "COMMON_STOCK",
      "isPublic": true,
      "disabled": true,
      "files": [
        "string"
      ],
      "organizerFiles": [
        "string"
      ],
      "estimatedCloseDate": "2019-08-24T14:15:22Z",
      "organizerCarryPercentage": 100,
      "additionalCarryRecipients": [
        {
          "individual": {
            "id": "string",
            "ownerId": "string",
            "name": "string",
            "type": "string",
            "title": "string",
            "isUSBased": true,
            "address": {},
            "phone": "string",
            "email": "string",
            "taxDetails": {},
            "dateOfBirth": "string",
            "stateOfFormation": "string",
            "countryOfFormation": "string",
            "taxIdType": "string",
            "taxId": "string",
            "passport": "string"
          },
          "carryPercentage": 0
        }
      ],
      "portfolioCompanyContact": {},
      "status": "DRAFT",
      "closes": [
        "string"
      ],
      "requireQualifiedPurchaser": true,
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "profileId": "string",
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request DealsList

Entities

An entity (typically a fund) is the legal entity that gets generated during the deal creation process.

Get the balance from the Entity Bank Account

Code samples

# You can also use wget
curl -X GET /entities/{entityId}/bank-account/balance \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/bank-account/balance',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/bank-account/balance',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}/bank-account/balance', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}/bank-account/balance', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns the balance from the Entity Bank Account (if present)

Endpoint

GET /entities/{entityId}/bank-account/balance Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Example responses

200 Response

0

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request number

Get details about the Entity Bank Account

Code samples

# You can also use wget
curl -X GET /entities/{entityId}/bank-account/details \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/bank-account/details',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/bank-account/details',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}/bank-account/details', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}/bank-account/details', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns details about the Entity Bank Account (if present)

Endpoint

GET /entities/{entityId}/bank-account/details Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Example responses

200 Response

0

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request number

Get the Transactions from the Entity Bank Account

Code samples

# You can also use wget
curl -X GET /entities/{entityId}/bank-account/transactions \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/bank-account/transactions',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/bank-account/transactions',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}/bank-account/transactions', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}/bank-account/transactions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns the Transaction Listing from the Entity Bank Account (if present)

Endpoint

GET /entities/{entityId}/bank-account/transactions Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Example responses

200 Response

[
  null
]

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Inline

Response Schema

Create a Bank Account for an Entity

Code samples

# You can also use wget
curl -X POST /entities/{entityId}/bank-account \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/bank-account',
  method: 'post',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/bank-account',
{
  method: 'POST',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/entities/{entityId}/bank-account', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities/{entityId}/bank-account', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Creates a Bank Account for the Series Entity. An EIN for the entity is required for this request to succeed. Only one Bank Account is allowed per Entity

Endpoint

POST /entities/{entityId}/bank-account Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Responses

Status Meaning Description Schema
204 No Content Expected response to a valid request None

Code samples

# You can also use wget
curl -X GET /entities/{entityId}/blue-sky-amounts \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/blue-sky-amounts',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/blue-sky-amounts',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}/blue-sky-amounts', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}/blue-sky-amounts', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Given a specific entity id, this will return a count of investors per state, the amount invested per state, and the date of the first investment

GET /entities/{entityId}/blue-sky-amounts Try it out

Parameter In Type Required Description
entityId path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}
Status Meaning Description Schema
200 OK Expected response to a valid request Entities

Get a document for an Entity

Code samples

# You can also use wget
curl -X GET /entities/{entityId}/documents/{documentType} \
  -H 'Accept: text/plain' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'text/plain',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/documents/{documentType}',
  method: 'get',

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

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

const headers = {
  'Accept':'text/plain',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/documents/{documentType}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'text/plain',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}/documents/{documentType}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'text/plain',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}/documents/{documentType}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get the specified documentType for the Entity

Endpoint

GET /entities/{entityId}/documents/{documentType} Try it out

Parameters

Parameter In Type Required Description
entityId path string true none
documentType path string true none

Example responses

200 Response

{"id":"string","ownerId":"string","tenantId":"string","name":"string","size":"string","type":"string","key":"string","thumbnail":"string","lastModified":"string","createdAt":"2019-08-24T14:15:22Z","updatedAt":"2019-08-24T14:15:22Z","deletedAt":"2019-08-24T14:15:22Z","isDeleted":true,"generating":true,"isPublic":true,"additionalProperties":{}}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request FilePartial

Generate a document for an Entity

Code samples

# You can also use wget
curl -X POST /entities/{entityId}/generate-documents/{documentType} \
  -H 'Content-Type: application/json' \
  -H 'Accept: text/plain' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'text/plain',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/generate-documents/{documentType}',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'text/plain',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/generate-documents/{documentType}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'text/plain',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/entities/{entityId}/generate-documents/{documentType}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'text/plain',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities/{entityId}/generate-documents/{documentType}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Generate the specified documentType for the Entity

Endpoint

POST /entities/{entityId}/generate-documents/{documentType} Try it out

Body parameter

{}

Parameters

Parameter In Type Required Description
entityId path string true none
documentType path string true none
body body object false none

Example responses

200 Response

{"id":"string","ownerId":"string","tenantId":"string","name":"string","size":"string","type":"string","key":"string","thumbnail":"string","lastModified":"string","createdAt":"2019-08-24T14:15:22Z","updatedAt":"2019-08-24T14:15:22Z","deletedAt":"2019-08-24T14:15:22Z","isDeleted":true,"generating":true,"isPublic":true,"additionalProperties":{}}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request FilePartial

Send ACH out

Code samples

# You can also use wget
curl -X POST /entities/{entityId}/initACHTransfer \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/initACHTransfer',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "amount": 0.01,
  "beneficiaryId": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/initACHTransfer',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/entities/{entityId}/initACHTransfer', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities/{entityId}/initACHTransfer', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

This is used to send money out using a ach transfer

Endpoint

POST /entities/{entityId}/initACHTransfer Try it out

Body parameter

{
  "amount": 0.01,
  "beneficiaryId": "string"
}

Parameters

Parameter In Type Required Description
entityId path string true none
body body object false none
» amount body number true none
» beneficiaryId body string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Send wires out

Code samples

# You can also use wget
curl -X POST /entities/{entityId}/initTransfer \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/initTransfer',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "amount": 0.01,
  "beneficiaryId": "string",
  "instructions": "string",
  "scheduledForDate": "2019-08-24"
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/initTransfer',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/entities/{entityId}/initTransfer', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities/{entityId}/initTransfer', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

This is used to send money out using a wire transfer

Endpoint

POST /entities/{entityId}/initTransfer Try it out

Body parameter

{
  "amount": 0.01,
  "beneficiaryId": "string",
  "instructions": "string",
  "scheduledForDate": "2019-08-24"
}

Parameters

Parameter In Type Required Description
entityId path string true none
body body object false none
» amount body number true none
» beneficiaryId body string true none
» instructions body string true none
» scheduledForDate body string(date) false none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create an EIN for the Series Entity

Code samples

# You can also use wget
curl -X POST /entities/{entityId}/series-ein \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}/series-ein',
  method: 'post',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}/series-ein',
{
  method: 'POST',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/entities/{entityId}/series-ein', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities/{entityId}/series-ein', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Creates a request for an EIN on the specified Entity

Endpoint

POST /entities/{entityId}/series-ein Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Responses

Status Meaning Description Schema
204 No Content Expected response to a valid request None

Update an Entity

Code samples

# You can also use wget
curl -X PUT /entities/{entityId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/entities/{entityId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/entities/{entityId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update an Entity with the supplied data

Endpoint

PUT /entities/{entityId} Try it out

Body parameter

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
entityId path string true none
body body EntitiesPartial false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Entities

Get an Entity by Id

Code samples

# You can also use wget
curl -X GET /entities/{entityId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities/{entityId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities/{entityId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get the Entity

Endpoint

GET /entities/{entityId} Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Entities

Delete an Entity

Code samples

# You can also use wget
curl -X DELETE /entities/{entityId} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities/{entityId}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/entities/{entityId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/entities/{entityId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/entities/{entityId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Delete the Entity with the specified Id

Endpoint

DELETE /entities/{entityId} Try it out

Parameters

Parameter In Type Required Description
entityId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create an Entity

Code samples

# You can also use wget
curl -X POST /entities \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/entities', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/entities', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create an entity with the supplied data

Endpoint

POST /entities Try it out

Body parameter

{
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
body body NewEntity false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "dealId": "string",
  "name": "string",
  "entityType": "LIMITED_LIABILITY_COMPANY",
  "regulationType": "REGULATION_D",
  "regDExemption": "string",
  "minInvestmentAmount": 6000000,
  "countryOfFormation": "string",
  "stateOfFormation": "string",
  "entityDocuments": {},
  "files": [
    "string"
  ],
  "ein": "string",
  "assetComposition": "string",
  "arbitration": {},
  "registeredAgent": "string",
  "bankAccount": {},
  "managementFee": {},
  "expenseReserve": {},
  "legalIncOrder": {},
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "managerId": "string",
  "masterEntityId": "string",
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Entities

List Entities

Code samples

# You can also use wget
curl -X GET /entities \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/entities',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/entities',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/entities', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/entities', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

List Entities for the current user

Endpoint

GET /entities Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "dealId": "string",
      "name": "string",
      "entityType": "LIMITED_LIABILITY_COMPANY",
      "regulationType": "REGULATION_D",
      "regDExemption": "string",
      "minInvestmentAmount": 6000000,
      "countryOfFormation": "string",
      "stateOfFormation": "string",
      "entityDocuments": {},
      "files": [
        "string"
      ],
      "ein": "string",
      "assetComposition": "string",
      "arbitration": {},
      "registeredAgent": "string",
      "bankAccount": {},
      "managementFee": {},
      "expenseReserve": {},
      "legalIncOrder": {},
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "managerId": "string",
      "masterEntityId": "string",
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request EntitiesList

Files

Files of all kinds that can be attached to other objects or stand alone.

Upload a File

Code samples

# You can also use wget
curl -X POST /files/upload \
  -H 'Content-Type: multipart/form-data' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'multipart/form-data',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files/upload',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "file": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Authorization':'Bearer {access-token}'

};

fetch('/files/upload',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/files/upload', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'multipart/form-data',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/files/upload', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Upload a file

Endpoint

POST /files/upload Try it out

Body parameter

file: string

Parameters

Parameter In Type Required Description
body body object true Request body for multipart/form-data based file upload
» file body string(binary) false none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Download a File

Code samples

# You can also use wget
curl -X GET /files/{fileId}/download \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files/{fileId}/download',
  method: 'get',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/files/{fileId}/download',
{
  method: 'GET',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/files/{fileId}/download', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/files/{fileId}/download', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Download a File

Endpoint

GET /files/{fileId}/download Try it out

Parameters

Parameter In Type Required Description
fileId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Update a File

Code samples

# You can also use wget
curl -X PUT /files/{fileId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files/{fileId}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/files/{fileId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.put('/files/{fileId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/files/{fileId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Update a File with the supplied data

Endpoint

PUT /files/{fileId} Try it out

Body parameter

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
fileId path string true none
body body FilePartial false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request File

Get a File

Code samples

# You can also use wget
curl -X GET /files/{fileId} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files/{fileId}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/files/{fileId}',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/files/{fileId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/files/{fileId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Returns a File with the specified Id

Endpoint

GET /files/{fileId} Try it out

Parameters

Parameter In Type Required Description
fileId path string true none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request File

Delete a File

Code samples

# You can also use wget
curl -X DELETE /files/{fileId} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files/{fileId}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/files/{fileId}',
{
  method: 'DELETE',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('/files/{fileId}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/files/{fileId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Deletes the File with the specified Id

Endpoint

DELETE /files/{fileId} Try it out

Parameters

Parameter In Type Required Description
fileId path string true none

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request None

Create a File

Code samples

# You can also use wget
curl -X POST /files \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/files',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/files', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/files', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Create a File record

Endpoint

POST /files Try it out

Body parameter

{
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}

Parameters

Parameter In Type Required Description
body body NewFile false none

Example responses

200 Response

{
  "id": "string",
  "ownerId": "string",
  "tenantId": "string",
  "name": "string",
  "size": "string",
  "type": "string",
  "key": "string",
  "thumbnail": "string",
  "lastModified": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "updatedAt": "2019-08-24T14:15:22Z",
  "deletedAt": "2019-08-24T14:15:22Z",
  "isDeleted": true,
  "generating": true,
  "isPublic": true,
  "additionalProperties": {}
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request File

Get Files for the current User

Code samples

# You can also use wget
curl -X GET /files \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/files',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/files',
{
  method: 'GET',

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

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/files', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/files', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Get a list of Files for the current user

Endpoint

GET /files Try it out

Parameters

Parameter In Type Required Description
perPage query number false none
page query number false none

Example responses

200 Response

{
  "data": [
    {
      "id": "string",
      "ownerId": "string",
      "tenantId": "string",
      "name": "string",
      "size": "string",
      "type": "string",
      "key": "string",
      "thumbnail": "string",
      "lastModified": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "updatedAt": "2019-08-24T14:15:22Z",
      "deletedAt": "2019-08-24T14:15:22Z",
      "isDeleted": true,
      "generating": true,
      "isPublic": true,
      "additionalProperties": {}
    }
  ],
  "page": 0,
  "perPage": 0,
  "totalCount": 0
}

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request FilesList

Invites

Used for onboarding new users. The invite object can conveniently create all the objects required when a new user is created.

Accept Invite Object

Code samples

# You can also use wget
curl -X POST /invites/{inviteId}/accept?userId=string \
  -H 'Accept: application/json' \
  -H 'x-tenant-id: string' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/invites/{inviteId}/accept',
  method: 'post',
  data: '?userId=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

fetch('/invites/{inviteId}/accept?userId=string',
{
  method: 'POST',

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

import requests
headers = {
  'Accept': 'application/json',
  'x-tenant-id': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/invites/{inviteId}/accept', params={
  'userId': 'string'
}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'x-tenant-id' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/invites/{inviteId}/accept', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Accept Invite Object

Endpoint

POST /invites/{inviteId}/accept Try it out

Parameters

Parameter In Type Required Description
inviteId path string true Invite Object ID
userId query string true User ID of acceptor
x-tenant-id header string true Your Tenant ID

Example responses

Example Invite Object

[
  {
    "id": "60381e064b79321012eac5b7",
    "ownerId": "483f401f-cfae-4972-b62c-e3c9d7472585",
    "tenantId": "gbt",
    "acceptableBy": "john@example.com",
    "invitedTo": [
      {
        "id": "60381e06fb79320012e8c5b3",
        "type": "deal",
        "relation": "subscription"
      }
    ],
    "invitedRole": "investor",
    "createdAt": "2021-02-25T22:03:47.727Z",
    "updatedAt": "2021-02-25T22:15:29.276Z",
    "isDeleted": false,
    "acceptedAt": "2021-02-25T22:15:29.276Z",
    "redirectUrl": "/subscriptions/60382181fb79320012e8c5b6"
  }
]

Responses

Status Meaning Description Schema
200 OK Expected response to a valid request Invite

Legal

Formations, filings and compliance.

Get count of formation requests

Code samples

# You can also use wget
curl -X GET /legal/formation/requests/count \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/legal/formation/requests/count',
  method: 'get',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/legal/formation/requests/count',
{
  method: 'GET',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/legal/formation/requests/count', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/legal/formation/requests/count', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Endpoint

GET /legal/formation/requests/count Try it out

Parameters

Parameter In Type Required Description
where query object false none

Responses

Status Meaning Description Schema
description Unknown none None
content Unknown none None

Request an EIN

Code samples

# You can also use wget
curl -X POST /legal/formation/requests/ein-only \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'x-tenant-id: string' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/legal/formation/requests/ein-only',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "entity": {
    "name": "Test Series 1, a Series of Test Master LLC",
    "type": "LLC",
    "stateOfFormation": "Delaware"
  },
  "taxContact": {
    "firstName": "John",
    "lastName": "Doe",
    "phone": "555-555-5555",
    "taxDetails": {
      "type": "ssn",
      "value": "111-11-1111"
    },
    "address": {
      "street1": "Example Street",
      "city": "Salt Lake City",
      "postalCode": "84005",
      "state": "Utah",
      "country": "United States of America"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'x-tenant-id':'string',
  'Authorization':'Bearer {access-token}'

};

fetch('/legal/formation/requests/ein-only',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'x-tenant-id': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('/legal/formation/requests/ein-only', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'x-tenant-id' => 'string',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/legal/formation/requests/ein-only', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Request an EIN

Endpoint

POST /legal/formation/requests/ein-only Try it out

Body parameter

Example Formation Request for EIN

{
  "entity": {
    "name": "Test Series 1, a Series of Test Master LLC",
    "type": "LLC",
    "stateOfFormation": "Delaware"
  },
  "taxContact": {
    "firstName": "John",
    "lastName": "Doe",
    "phone": "555-555-5555",
    "taxDetails": {
      "type": "ssn",
      "value": "111-11-1111"
    },
    "address": {
      "street1": "Example Street",
      "city": "Salt Lake City",
      "postalCode": "84005",
      "state": "Utah",
      "country": "United States of America"
    }
  }
}

Parameters

Parameter In Type Required Description
x-tenant-id header string true Your Tenant ID
body body NewFormationRequest true none

Example responses

Example Formation Response for EIN

{
  "id": "53709c46-45fc-40b9-aa83-be8211b230b7",
  "entity": {
    "name": "Test Series 1, a Series of Test Master LLC",
    "type": "LLC",
    "stateOfFormation": "Delaware"
  },
  "taxContact": {
    "firstName": "John",
    "lastName": "Doe",
    "phone": "555-555-5555",
    "taxDetails": {
      "type": "ssn"
    },
    "address": {
      "street1": "Example Street",
      "city": "Salt Lake City",
      "postalCode": "84005",
      "state": "Utah",
      "country": "United States of America"
    }
  },
  "status": "ORDER_PLACED",
  "ein": null
}

Responses

Status Meaning Description Schema
200 OK FormationRequest instance for EIN Only order FormationRequest
422 Unprocessable Entity FormationRequest Body is Invalid None

Order an Entity

Code samples

# You can also use wget
curl -X POST /legal/formation/requests/entity \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/legal/formation/requests/entity',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "taxContact": {
    "taxDetails": {
      "type": "ssn",
      "value": "string"
    },
    "firstName": "string",
    "lastName": "string",
    "phone": "string",
    "address": {
      "street1": "string",
      "street2": "string",
      "city": "string",
      "state": "string",
      "postalCode": "string",
      "country": "United States of America"
    }
  },
  "entity": {
    "name": "string",
    "type": "LLC",
    "stateOfFormation": "string",
    "address": {
      "street1": "string",
      "street2": "string",
      "city": "string",
      "state": "string",
      "postalCode": "string",
      "country": "United States of America"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('/legal/formation/requests/entity',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

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

r = requests.post('/legal/formation/requests/entity', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/legal/formation/requests/entity', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Request an Entity

Endpoint

POST /legal/formation/requests/entity Try it out

Body parameter

{
  "taxContact": {
    "taxDetails": {
      "type": "ssn",
      "value": "string"
    },
    "firstName": "string",
    "lastName": "string",
    "phone": "string",
    "address": {
      "street1": "string",
      "street2": "string",
      "city": "string",
      "state": "string",
      "postalCode": "string",
      "country": "United States of America"
    }
  },
  "entity": {
    "name": "string",
    "type": "LLC",
    "stateOfFormation": "string",
    "address": {
      "street1": "string",
      "street2": "string",
      "city": "string",
      "state": "string",
      "postalCode": "string",
      "country": "United States of America"
    }
  }
}

Parameters

Parameter In Type Required Description
body body FormationRequestEntityRequest false none

Example responses

Example Formation Response for EIN

{
  "id": "53709c46-45fc-40b9-aa83-be8211b230b7",
  "entity": {
    "name": "Test Series 1, a Series of Test Master LLC",
    "type": "LLC",
    "stateOfFormation": "Delaware"
  },
  "taxContact": {
    "firstName": "John",
    "lastName": "Doe",
    "phone": "555-555-5555",
    "taxDetails": {
      "type": "ssn"
    },
    "address": {
      "street1": "Example Street",
      "city": "Salt Lake City",
      "postalCode": "84005",
      "state": "Utah",
      "country": "United States of America"
    }
  },
  "status": "ORDER_PLACED"
}

Responses

Status Meaning Description Schema
200 OK FormationRequest instance for Entity order FormationRequest
422 Unprocessable Entity FormationRequest Body is Invalid None

Get formation request by id

Code samples

# You can also use wget
curl -X GET /legal/formation/requests/{id} \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: '/legal/formation/requests/{id}',
  method: 'get',

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

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

const headers = {
  'Authorization':'Bearer {access-token}'

};

fetch('/legal/formation/requests/{id}',
{
  method: 'GET',

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

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('/legal/formation/requests/{id}', params={

}, headers = headers)

print r.json()

<?php

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/legal/formation/requests/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

Endpoint

GET /legal/formation/requests/{id} Try it out

Parameters

Parameter In Type Required Description
id path string true none
filter query FormationRequest.Filter false none

Responses

Status Meaning Description Schema
description Unknown none None
content Unknown none None

List formation requests

Code samples

# You can also use wget
curl -X GET /legal/formation/requests \
  -H 'Authorization: Bearer {access-token}'

var headers = {
  'Authorization'