Vault API

  • SECTIONS
  • Overview
  • API Definition
  • API Documentation
  • SDK Libraries
  • FactSet Connectors
  • Code Snippet
  • Changelog
Overview

The FactSet Vault API delivers robust capabilities tailored for financial professionals seeking advanced portfolio management solutions. This API facilitates in-depth analysis and seamless portfolio performance data management across multiple asset classes, which are pivotal for informed investment decision-making.

Key Features:

  • Integrated Data Management: The FactSet Vault API ensures streamlined data management and integration, accommodating a vast array of asset classes and data types. This feature allows the aggregation of diverse data from various sources, enabling a holistic view of portfolio investments.

  • Performance Measurement and Attribution: Provides detailed performance analytics and attribution models that aid in understanding the drivers of portfolio returns. Such insights are crucial for assessing the effectiveness of investment strategies and justifying the decisions taken.

  • Customizable Reporting: The API supports the generation of customized reports that help display and analyze data effectively. Although direct visualization isn't provided by the API, the data formatted can be easily used with third-party visualization tools for enhanced graphical representation.

  • Scalability and Batch Processing: Designed to facilitate operations for institutions of all sizes, the Vault API offers scalable solutions to manage demands from single portfolios to large-scale operations with numerous portfolios. Batch processing capabilities enhance efficiencies and manage high-volume data needs seamlessly.

  • Adherence to Compliance and Security Standards: FactSet Vault API emphasizes rigorous security protocols and compliance adherence, ensuring that data handling meets global regulatory standards and maintains data integrity.

Benefits in Practice:

  • Operational Efficiency: Automates essential but time-consuming tasks, decreasing the operational burden and increasing efficiency in portfolio management workflows.

  • Enhanced Decision Making: With access to comprehensive data and sophisticated analytical tools, managers can execute informed decisions faster, optimizing the portfolio performance.

  • Flexibility: The API's design caters to varying user needs, offering flexibility in data consumption, analysis, and report generation.

  • Real-World Application: FactSet's case studies illustrate how the Vault API has been instrumental in transforming the portfolio management process for enterprises. Firms leveraging this API reported improvements in managing portfolio data, performance measurement, and client reporting, thereby enhancing overall service quality and client satisfaction.

An example workflow is given below:

  1. Identify the Component ID by passing the underlying Portfolio Insights document as an input to the /components endpoint.
  2. Identify the Configuration ID by passing the Vault underlying Account as an input to the /configurations endpoint.
  3. This Configuration ID can be used as an input to configurations/{id} endpoint to get details associated with Vault Configuration passed the list of accounts, lockingDate etc. The lockingDate parameter in the response can help in identifying if the vault configuration data is locked or unlocked.
  4. Input the Component ID and Configuration ID obtained from step #1, #2 into the request body of POST /calculations endpoint and trigger the calculation request.
  5. The results will be given back if calculated within the X-FactSet-Api-Long-Running-Deadline header value provided by user (in seconds) or you get back a calculation ID in POST response. This Calculation ID can then be passed to /calculations/{id}/status endpoint to get the status of the calculation and then use the /calculation/{id}/units/{unitID}/result endpoint to consume the results associated with calculation units that have status updated as completed.

Additional Notes:

  • Data Accessibility: All data must be stored in the Vault applications for it to be accessible via the API. Please liaise with your FactSet account and Vault implementation teams to have the proper setup for seamless API use.

  • Data Management: Account locking features are limited to the UI only, and are not accessible via the API.

Please use the Report Issue or Try For Free buttons to find out more.

API Definition
SDK Libraries
Code Snippet
Building and running a single calculation
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using FactSet.Protobuf.Stach.Extensions;
using FactSet.SDK.Vault.Api;
using FactSet.SDK.Vault.Client;
using FactSet.SDK.Vault.Model;
using FactSet.SDK.Utils.Authentication;

namespace FactSet.AnalyticsAPI.VaultESDK.Example
{
    public class VaultEngineSingleUnitExample
    {
        private static readonly string BasePath = Environment.GetEnvironmentVariable("FACTSET_HOST");
        private static readonly string UserName = Environment.GetEnvironmentVariable("FACTSET_USERNAME");
        private static readonly string Password = Environment.GetEnvironmentVariable("FACTSET_PASSWORD");
        private const string VaultDefaultDocument = "Client:/aapi/VAULT_QA_PI_DEFAULT_LOCKED";
        private const string VaultComponentName = "Total Returns";
        private const string VaultComponentCategory = "Performance / Performance Relative Dates";
        private const string VaultDefaultAccount = "CLIENT:/BISAM/REPOSITORY/QA/SMALL_PORT.ACCT";
        private const string VaultStartDate = "20180101";
        private const string VaultEndDate = "20180329";
        private const string VaultFrequency = "Monthly";
        private static SDK.Vault.Client.Configuration _engineApiConfiguration;

        public static async Task Main(string[] args)
        {
            try
            {
                var vaultCalculationParameters = await GetVaultCalculationParametersAsync();
                var calculationParameters = new VaultCalculationParametersRoot
                {
                    Data = new Dictionary<string, VaultCalculationParameters> { { "1", vaultCalculationParameters } }
                };

                var calculationApi = new VaultCalculationsApi(await GetApiConfigurationAsync());

                var calculationResponse = calculationApi.PostAndCalculateWithHttpInfo(null, null, calculationParameters);
                // Comment the above line and uncomment the below lines to add cache control configuration. Results are by default cached for 12 hours; Setting max-stale=300 will fetch a cached result which is at max 5 minutes older. max-stale=0 will be a fresh adhoc run and the max-stale value is in seconds.
                //var cacheControl = "max-stale=300";
                //var calculationResponse = calculationApi.PostAndCalculateWithHttpInfo(null, cacheControl, calculationParameters);

                if (calculationResponse.StatusCode == HttpStatusCode.Created)
                {
                    ObjectRoot result = (ObjectRoot)calculationResponse.Data.Response;
                    PrintResult(result);
                    return;
                }

                CalculationStatusRoot status = (CalculationStatusRoot)calculationResponse.Data.Response;
                var calculationId = status.Data.Calculationid;
                Console.WriteLine("Calculation Id: " + calculationId);
                ApiResponse<CalculationStatusRoot> getStatusResponse = null;

                while (status.Data.Status == CalculationStatus.StatusEnum.Queued || status.Data.Status == CalculationStatus.StatusEnum.Executing)
                {
                    if (getStatusResponse != null)
                    {
                        if (getStatusResponse.Headers.ContainsKey("Cache-Control"))
                        {
                            var maxAge = getStatusResponse.Headers["Cache-Control"][0];
                            if (string.IsNullOrWhiteSpace(maxAge))
                            {
                                Console.WriteLine("Sleeping for 2 seconds");
                                // Sleep for at least 2 seconds.
                                Thread.Sleep(2000);
                            }
                            else
                            {
                                var age = int.Parse(maxAge.Replace("max-age=", ""));
                                Console.WriteLine($"Sleeping for {age} seconds");
                                Thread.Sleep(age * 1000);
                            }
                        }
                    }

                    getStatusResponse = calculationApi.GetCalculationStatusByIdWithHttpInfo(calculationId);
                    status = getStatusResponse.Data;
                }
                Console.WriteLine("Calculation Completed");


                foreach (var vaultCalculation in status.Data.Units)
                {
                    if (vaultCalculation.Value.Status == CalculationUnitStatus.StatusEnum.Success)
                    {
                        var resultResponse = calculationApi.GetCalculationUnitResultByIdWithHttpInfo(calculationId, vaultCalculation.Key);
                        Console.WriteLine($"Calculation Unit Id : {vaultCalculation.Key} Result!!!");
                        PrintResult(resultResponse.Data);
                    }
                    else
                    {
                        Console.WriteLine($"Calculation Unit Id : {vaultCalculation.Key} Failed!!!");
                        Console.WriteLine($"CalculationId:UnitId : {vaultCalculation.Value.Errors?.FirstOrDefault()?.Id}");
                        Console.WriteLine($"Error message : {vaultCalculation.Value.Errors?.FirstOrDefault()?.Detail}");
                    }
                }

                Console.ReadKey();
            }
            catch (ApiException e)
            {
                Console.WriteLine("Exception when calling VaultCalculationsApi : " + e.Message);
                Console.WriteLine($"Status Code: {e.ErrorCode}");
                Console.WriteLine(e.StackTrace);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        private static async Task<SDK.Vault.Client.Configuration> GetApiConfigurationAsync()
        {
            //Supported authentication methods are below,
            //choose one that satisfies your use case.

            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            if (_engineApiConfiguration != null)
            {
                return _engineApiConfiguration;
            }

            #region BasicAuthentication

            /* Basic authentication: FactSetApiKey */
            // See https://github.com/FactSet/enterprise-sdk#api-key
            // for information how to create an API key
            _engineApiConfiguration = new SDK.Vault.Client.Configuration
            {
                BasePath = BasePath,
                Username = UserName,
                Password = Password,
            };
            #endregion

            //Uncomment below lines for adding the proxy configuration
            //System.Net.WebProxy webProxy = new System.Net.WebProxy("http://myProxyUrl:80/");
            //webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
            //_engineApiConfiguration.Proxy = webProxy;

            #region FactSetOAuth2
            /* (Preferred) OAuth 2.0: FactSetOAuth2 */
            // See https://github.com/FactSet/enterprise-sdk#oauth-20
            // for information on how to create the app-config.json file
            // See https://github.com/FactSet/enterprise-sdk-utils-dotnet#authentication
            // for more information on using the ConfidentialClient class

            //Uncomment below lines and comment the above lines(region:BasicAuthentication) for FactSetOAuth2 Authentication
            //ConfidentialClient confidentialClient = await ConfidentialClient.CreateAsync("");
            //_engineApiConfiguration = new FactSet.SDK.Vault.Client.Configuration();
            //_engineApiConfiguration.OAuth2Client = confidentialClient; 
            #endregion

            return _engineApiConfiguration;
        }


        private static async Task<VaultCalculationParameters> GetVaultCalculationParametersAsync()
        {
            var componentsApi = new ComponentsApi(await GetApiConfigurationAsync());

            var componentsResponse = componentsApi.GetVaultComponents(VaultDefaultDocument);

            var vaultComponentId = componentsResponse.Data.FirstOrDefault(component => (component.Value.Name == VaultComponentName && component.Value.Category == VaultComponentCategory)).Key;
            Console.WriteLine($"Vault Component Id : {vaultComponentId}");

            var vaultAccount = new VaultIdentifier(VaultDefaultAccount);
            var vaultDates = new VaultDateParameters(VaultEndDate, VaultFrequency, VaultStartDate);

            var configurationApi = new ConfigurationsApi(await GetApiConfigurationAsync());
            var configurationResponse = configurationApi.GetVaultConfigurationsWithHttpInfo(vaultAccount.Id);
            var vaultConfigurationId = configurationResponse.Data.Data.Keys.First();

            var vaultCalculation = new VaultCalculationParameters(vaultComponentId, vaultAccount, vaultConfigurationId, vaultDates);

            return vaultCalculation;
        }

        private static void PrintResult(ObjectRoot result)
        {
            Console.WriteLine("Calculation Result");

            // converting the data to Package object
            var stachBuilder = StachExtensionFactory.GetRowOrganizedBuilder();
            var stachExtension = stachBuilder.SetPackage(result.Data).Build();
            // To convert package to 2D tables.
            var tables = stachExtension.ConvertToTable();

            Console.WriteLine(tables[0]);
        }
    }
}
Building and running multiple calculations
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using FactSet.Protobuf.Stach.Extensions;
using FactSet.SDK.Vault.Api;
using FactSet.SDK.Vault.Client;
using FactSet.SDK.Vault.Model;
using FactSet.SDK.Utils.Authentication;

namespace FactSet.AnalyticsAPI.VaultESDK.Example
{
    public class VaultEngineMultipleUnitExample
    {
        private static readonly string BasePath = Environment.GetEnvironmentVariable("FACTSET_HOST");
        private static readonly string UserName = Environment.GetEnvironmentVariable("FACTSET_USERNAME");
        private static readonly string Password = Environment.GetEnvironmentVariable("FACTSET_PASSWORD");
        private const string VaultDefaultDocument = "Client:/aapi/VAULT_QA_PI_DEFAULT_LOCKED";
        private const string VaultComponentName = "Total Returns";
        private const string VaultComponentCategory = "Performance / Performance Relative Dates";
        private const string VaultDefaultAccount = "CLIENT:/BISAM/REPOSITORY/QA/SMALL_PORT.ACCT";
        private const string VaultStartDate = "20180101";
        private const string VaultEndDate = "20180329";
        private const string VaultFrequency = "Monthly";
        private static SDK.Vault.Client.Configuration _engineApiConfiguration;

        public static async Task Main(string[] args)
        {
            try
            {
                var vaultCalculationParameters = await GetVaultCalculationParametersAsync();
                var calculationParameters = new VaultCalculationParametersRoot
                {
                    Data = new Dictionary<string, VaultCalculationParameters> { { "1", vaultCalculationParameters }, { "2", vaultCalculationParameters } }
                };

                var calculationApi = new VaultCalculationsApi(await GetApiConfigurationAsync());

                var calculationResponse = calculationApi.PostAndCalculateWithHttpInfo(null, null, calculationParameters);
                // Comment the above line and uncomment the below lines to add cache control configuration. Results are by default cached for 12 hours; Setting max-stale=300 will fetch a cached result which is at max 5 minutes older. max-stale=0 will be a fresh adhoc run and the max-stale value is in seconds.
                //var cacheControl = "max-stale=300";
                //var calculationResponse = calculationApi.PostAndCalculateWithHttpInfo(null, cacheControl, calculationParameters);

                CalculationStatusRoot status = (CalculationStatusRoot)calculationResponse.Data.Response;
                var calculationId = status.Data.Calculationid;
                Console.WriteLine("Calculation Id: " + calculationId);
                ApiResponse<CalculationStatusRoot> getStatusResponse = null;

                while (status.Data.Status == CalculationStatus.StatusEnum.Queued || status.Data.Status == CalculationStatus.StatusEnum.Executing)
                {
                    if (getStatusResponse != null)
                    {
                        if (getStatusResponse.Headers.ContainsKey("Cache-Control"))
                        {
                            var maxAge = getStatusResponse.Headers["Cache-Control"][0];
                            if (string.IsNullOrWhiteSpace(maxAge))
                            {
                                Console.WriteLine("Sleeping for 2 seconds");
                                // Sleep for at least 2 seconds.
                                Thread.Sleep(2000);
                            }
                            else
                            {
                                var age = int.Parse(maxAge.Replace("max-age=", ""));
                                Console.WriteLine($"Sleeping for {age} seconds");
                                Thread.Sleep(age * 1000);
                            }
                        }
                    }

                    getStatusResponse = calculationApi.GetCalculationStatusByIdWithHttpInfo(calculationId);
                    status = getStatusResponse.Data;
                }
                Console.WriteLine("Calculation Completed");


                foreach (var vaultCalculation in status.Data.Units)
                {
                    if (vaultCalculation.Value.Status == CalculationUnitStatus.StatusEnum.Success)
                    {
                        var resultResponse = calculationApi.GetCalculationUnitResultByIdWithHttpInfo(calculationId, vaultCalculation.Key);
                        Console.WriteLine($"Calculation Unit Id : {vaultCalculation.Key} Result!!!");
                        PrintResult(resultResponse.Data);
                    }
                    else
                    {
                        Console.WriteLine($"Calculation Unit Id : {vaultCalculation.Key} Failed!!!");
                        Console.WriteLine($"CalculationId:UnitId : {vaultCalculation.Value.Errors?.FirstOrDefault()?.Id}");
                        Console.WriteLine($"Error message : {vaultCalculation.Value.Errors?.FirstOrDefault()?.Detail}");
                    }
                }

                Console.ReadKey();
            }
            catch (ApiException e)
            {
                Console.WriteLine("Exception when calling VaultCalculationsApi : " + e.Message);
                Console.WriteLine($"Status Code: {e.ErrorCode}");
                Console.WriteLine(e.StackTrace);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        private static async Task<SDK.Vault.Client.Configuration> GetApiConfigurationAsync()
        {
            //Supported authentication methods are below,
            //choose one that satisfies your use case.

            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            if (_engineApiConfiguration != null)
            {
                return _engineApiConfiguration;
            }

            #region BasicAuthentication

            /* Basic authentication: FactSetApiKey */
            // See https://github.com/FactSet/enterprise-sdk#api-key
            // for information how to create an API key
            _engineApiConfiguration = new SDK.Vault.Client.Configuration
            {
                BasePath = BasePath,
                Username = UserName,
                Password = Password,
            };
            #endregion

            //Uncomment below lines for adding the proxy configuration
            //System.Net.WebProxy webProxy = new System.Net.WebProxy("http://myProxyUrl:80/");
            //webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
            //_engineApiConfiguration.Proxy = webProxy;

            #region FactSetOAuth2
            /* (Preferred) OAuth 2.0: FactSetOAuth2 */
            // See https://github.com/FactSet/enterprise-sdk#oauth-20
            // for information on how to create the app-config.json file
            // See https://github.com/FactSet/enterprise-sdk-utils-dotnet#authentication
            // for more information on using the ConfidentialClient class

            //Uncomment below lines and comment the above lines(region:BasicAuthentication) for FactSetOAuth2 Authentication
            //ConfidentialClient confidentialClient = await ConfidentialClient.CreateAsync("");
            //_engineApiConfiguration = new FactSet.SDK.Vault.Client.Configuration();
            //_engineApiConfiguration.OAuth2Client = confidentialClient; 
            #endregion

            return _engineApiConfiguration;
        }


        private static async Task<VaultCalculationParameters> GetVaultCalculationParametersAsync()
        {
            var componentsApi = new ComponentsApi(await GetApiConfigurationAsync());

            var componentsResponse = componentsApi.GetVaultComponents(VaultDefaultDocument);

            var vaultComponentId = componentsResponse.Data.FirstOrDefault(component => (component.Value.Name == VaultComponentName && component.Value.Category == VaultComponentCategory)).Key;
            Console.WriteLine($"Vault Component Id : {vaultComponentId}");

            var vaultAccount = new VaultIdentifier(VaultDefaultAccount);
            var vaultDates = new VaultDateParameters(VaultEndDate, VaultFrequency, VaultStartDate);

            var configurationApi = new ConfigurationsApi(await GetApiConfigurationAsync());
            var configurationResponse = configurationApi.GetVaultConfigurationsWithHttpInfo(vaultAccount.Id);
            var vaultConfigurationId = configurationResponse.Data.Data.Keys.First();

            var vaultCalculation = new VaultCalculationParameters(vaultComponentId, vaultAccount, vaultConfigurationId, vaultDates);

            return vaultCalculation;
        }

        private static void PrintResult(ObjectRoot result)
        {
            Console.WriteLine("Calculation Result");

            // converting the data to Package object
            var stachBuilder = StachExtensionFactory.GetRowOrganizedBuilder();
            var stachExtension = stachBuilder.SetPackage(result.Data).Build();
            // To convert package to 2D tables.
            var tables = stachExtension.ConvertToTable();

            Console.WriteLine(tables[0]);
        }
    }
}
Changelog

Version 3

Summary

  • Version 3.14.6 - Released on 05/27/2024
  • Version 3.14.5 - Released on 03/25/2024
  • Version 3.14.4 - Released on 18/12/2023
  • Version 3.14.3 - Released on 10/25/2023
  • Version 3.14.2 - Released on 09/25/2023
  • Version 3.14.1 - Released on 08/21/2023
  • Version 3.14.0 - Released on 07/24/2023
  • Version 3.13.0 - Released on 03/14/2023
  • Version 3.12.0 - Released on 01/23/2023
  • Version 3.11.0 - Released on 06/06/2022
  • Version 3.10.0 - Released on 04/18/2022
  • Version 3.9.1 - Released on 02/14/2022
  • Version 3.9.0 - Released on 11/22/2021
  • Version 3.8.0 - Released on 10/21/2021
  • Version 3.7.0 - Released on 09/20/2021
  • Version 3.6.0 - Released on 09/07/2021
  • Version 3.6.0 - Released on 08/23/2021
  • Version 3.5.0 - Released on 08/06/2021
  • Version 3.4.2 - Released on 07/28/2021
  • Version 3.4.1 - Released on 07/19/2021
  • Version 3.3.2 - Released on 07/12/2021
  • Version 3.3.1 - Released on 06/28/2021
  • Version 3.3.0 - Released on 06/07/2021
  • Version 3.2.0 - Released on 05/21/2021
  • Version 3.1.2 - Released on 04/21/2021
  • Version 3.1.1 - Released on 03/20/2021
  • Version 3.1.0 - Released on 03/18/2021
  • Version 3.0.0 - Released on 02/10/2021

Functionality Additions

  • Added support for component detail GROUPSALL to get all levels of the group in response [v3.14.0]
  • Added new Security Response headers [v3.12.0]
  • Added new Get All Calculations endpoint.[v3.11.0]
  • Calculation points will be returned in the GET status endpoints once the calculation completes successfully. [v3.9.0]
  • New field “path” in "GET by Component ID" endpoint response [v3.7.0]
  • New cache-control headers “Age” and “Last-Modified” [v3.6.0]
  • Deprecated "ContentOrganization" and "ContentType" in favor of "StachContentOrganization" and "CalculationFormat" [v3.3.1]
  • Support cache-control headers max-age, max-stale, max-stale & max-age [v3.1.0]
  • Initial Release [v3.0.0]

Changes

  • New "data" top-level object in request and response body
  • New (optional) "meta" top-level object in request and response body
  • STACH v2 returned in results
  • Cache control functionality
  • GET analytics/engines/{engine}/v3/calculations/{id} - now returns calculation parameters instead of calculation status
  • Updated lookup endpoint URLs

Bug Fixes

  • Fixed points issue for VAULT Engine API. [v3.14.6]
  • Improvised error messages for batch calculation 404 scenarios. [v3.14.6]
  • Without disclosing the internal details we improvised the conversion failure error messages. [v3.14.6]
  • Allowing 10000 model validation errors for engines apis. [v3.14.5]
  • Added example value for long-running request header. [v3.14.4]
  • Corrected the schema documentation of the getAllCalculation endpoint to make it depict the exact output. [v3.14.3]
  • Implemented Exponential backoff Retries to Batch Service. [v3.14.2]
  • Do not crash if the account doesn't have any termination date set but force-end-date-before-termination settings are set for the document. [v3.14.2]
  • Fixed standard error response in delete endpoint for 404 response code. [v3.14.1]
  • Removed mandatory field requirement for pageNumber in GET All Calculations endpoint. [v3.14.1]
  • Fix to support Inception Date in Vault GET Date endpoint. [v3.12.0]
  • Fixed an issue where progress percentage on calculation units was not included in POST or GET requests on Engines API [v3.8.0]
  • Supporting SECURITIES in the component detail option [v3.7.0]
  • Improved error messaging for Invalid component id [v3.6.0]
  • Minor bug fixes for a multi-unit calculation [v3.5.0]
  • Minor bug fixes [v3.4.1]
  • Fix for the decoding of v3 Document’s endpoint. [v3.3.2]
  • Fix to support row and column STACH content organizations [v3.3.2]
  • Fix vault configurations endpoint returning empty response body [v3.1.0]
  • Minor fixes for the SimplifiedRow STACH v2 format v[3.0.0]

v2

Summary

  • v2.9.0 - Released on 12/15/20
  • v2.8.2 - Released on 10/28/20
  • v2.8.1 - Released on 10/06/20
  • v2.8.0 - Released on 08/27/20
  • v2.7.0 - Released on 08/13/20
  • v2.6.2 - Released on 07/23/20
  • v2.6.1 - Released on 07/09/20
  • v2.6.0 - Released on 06/25/20
  • v2.5.1 - Released on 04/19/20
  • v2.5.0 - Released on 03/26/20
  • v2.4.1 - Released on 02/27/20
  • v2.4.0 - Released on 01/16/20
  • v2.3.0 - Released on 12/12/19
  • v2.2.0 - Released on 11/25/19
  • v2.1.0 - Released on 09/26/19
  • v2.0.0 - Released on 08/15/19

Functionality Additions

  • STACH v2.0 [v2.9.0]
  • Better logging [v2.5.1]
  • Performance improvements [v2.5.0]
  • Performance improvements [v2.4.1]
  • Renamed points to units and removed 25-unit limit per request. Points for billing will be handled asynchronously in the backend [v2.3.0]
  • Added error message when a calculation unit fails due to invalid parameters [v2.2.0]
  • Performance improvement [v2.2.0]
  • Added snapshot (Boolean) property in ‘Vault Component Settings Lookup’ endpoint [v2.1.0]
  • Added calculation metadata to the result pickup endpoint. The properties include settings used in ‘Run Multiple Calculations’ endpoint and account/benchmark defaults [v2.1.0]
  • Initial release [v2.0.0]

Changes

  • Renamed ‘pointscount’ property to ‘points’ in ‘Get All Active Calculations’ endpoint. Points count related response headers were also updated accordingly in ‘Run Multiple Calculations’ endpoint [v2.1.0]
  • Renamed ‘defaultAccount’, ‘defaultBenchmark’ and ‘currency’ properties to ‘account’, ‘benchmark’ and ‘currencyisocode’ properties respectively in ‘Vault Component Settings Lookup’ endpoint [v2.1.0]

Bug Fixes

  • Efficient handling of streaming results [v2.9.0]
  • Return 503 on Rate limit transient errors [v2.9.0]
  • Minor bug fixes [v2.8.2]
  • Sandbox: Returning Created (201) instead of Success (200) for interactive Post [v2.8.2]
  • Fixing a bug causing a crash while cancelling a calculation [v2.8.1]
  • Return 400 on null values in Accounts [v2.8.0]
  • Retrying internal failures [v2.6.2]
  • Cache control header fix [v2.6.0]
  • Rate limiting header fix [v2.6.0]
  • Minor bug fixes [v2.5.1]
  • Improved error handling for invalid requests [v2.2.0]
  • Consistent Component ID's irrespective of document path formatting and casing [v2.2.0]

v1 (Retired)

Summary

  • v1.1.0 - Released on 07/25/19
  • v1.0.0 - Released on 06/13/19

Functionality Additions

  • Added format parameter to Get Result Endpoint to switch between different output formats [v1.1.0]
  • Made document extension optional when using Component Lookup endpoint [v1.1.0]
  • Added ability to create, fetch, and delete multiple Vault calculations [v1.0.0]
  • Initial release [v1.0.0]

Changes

  • No changes

Bug Fixes

  • No bug fixes