NAV Navbar
Logo Go to API docs

Introduction

Quovo provides widgets that can easily be embedded and customized to fit within your own website or application. Get your users connected faster and start leveraging robust account data to power your own experience. Our widgets are built mobile responsive and work with all recent versions of major browsers. Getting started with our widgets takes just a few minutes, and is described in the documentation below.

Access Tokens

Getting an Access Token

curl -X POST -H "Authorization: Bearer a724809d37d0a21b7e9257f45cee416f5aec61993ab4b09e" "https://api.quovo.com/v3/users/523479/ui_token"
{
  "ui_token": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJvbmVfdGltZV91c2UiOnRydWUsImlwX3Jlc3RyaWN0ZWQiOmZhbHNlLCJzdWIiOiI1MjM0NzkiLCJleHAiOjE0ODQ5NTIzNjQsImlwIjoiMTI3LjAuMC4xIiwiaWF0IjoxNDg0OTQ4NzY0LCJ0eXBlIjoiaWZyYW1lIiwiaWQiOiIzZWI1ZjJjNTIxMjdiODU2NDUzMDM1NTU1MGRhMTM5MTczODE0MGQ4IiwidXNlciI6NTIzNDc5fQ.XT-lOL5GBTASXAX8CFOaNO_fOr2W6BhrPe1Pfa695SE",
    "user_id": 523479
  }
}

Quovo UI widgets authenticate on a per-user basis, requiring a single-use access token every time an embedded widget or handler is created. For more information on creating a token see the API v3 Reference Documentation.

You can then use this token to authenticate a single Quovo UI widget, which is detailed in the integration sections below. Any connection added within Connect or through other Quovo widgets will be tied to the userId passed in the access token call.

Connect

Connect is a easy-to-use widget that you can embed into your web and mobile apps to help your users link their financial accounts. Connect integrates with the rest of Quovo’s API suite, providing a seamless and user-friendly sync process. Setting up Connect takes just a few minutes, and is described in the documentation below.

Simple Integrations

<div id="quovo-widget"></div>
<!-- {token} is generated by a backend process every time the page is loaded. -->
<script
  type="text/javascript"
  src="https://app.quovo.com/ui.js"
  data-connect-id="quovo-widget"
  data-token="{token}">
</script>

With a simple integration, you can integrate Connect in just a few lines of code.

Add the ui.js script to your page, passing in the ID of an HTML element and a user-specific access token through data- attributes. This will automatically create a “Connect Your Accounts” button, which opens Connect when clicked. (In the example to the right, {token} is generated by a backend process every time the page is loaded.)

The available attributes on the <script> element are:

Attribute Description
data-connect-id The id of an HTML element. This element will be replaced with a button, used to open Connect.
data-token A user-specific access token. This is used to authenticate the user and gain access to Connect.

Custom Integrations

<script type="text/javascript" src="https://app.quovo.com/ui.js"></script>
<button id="quovo-connect">Connect Your Accounts</button>

<script>
  function setupConnect(token) {
    var handler = Quovo.create({
      token: token,
      // optional function parameters
      onLoad: function() {
        console.log('loaded');
      },
      onAdd: function(err, event) {
        if (!err) {
          console.log('Connection', event.connection.id, 'added!');
        }
      },
      // optional string parameter
      topInstitutions: 'banks',
    });

    var connect = document.getElementById('quovo-connect');
    connect.addEventListener('click', function(event) {
      handler.open();
      event.preventDefault();
    });
  }

  // getConnectToken is an asynchronous function that fetches a user-specific
  // Connect access token. Since this function depends on the structure of
  // your server-side code, it is not defined here.
  getConnectToken(setupConnect);
</script>

With a custom integration, you can have more fine-tuned control over Connect, deciding when and how it opens, what should happen after it closes, and more.

After loading the ui.js script, the Quovo Connect library will be available as the Javascript variable Quovo. Call Quovo.create to create a handler for Connect, allowing you to open or close the app as necessary. (In the example to the right, getConnectToken is an asynchronous function that fetches a user-specific Connect access token. Since this function depends on the structure of your server-side code, it is not defined here.)

The available parameters to Quovo.create are:

Field Type Description
token string [required] A user-specific access token. This is used to authenticate the user and gain access to Connect.
onLoad function A callback function triggered after Connect is done loading.
onOpen function A callback function triggered every time Connect is opened.
onClose function A callback function triggered every time Connect is closed.
onAdd function A callback function triggered anytime a Quovo connection is created within Connect.
onSync function A callback function triggered when a connection is synced through Connect.
onAuthenticate function A callback function triggered when a connection has completed authentication successfully, but may not have yet completed loading and analyzing all account data.
onAuthDepositRequest function A callback function triggered when an Auth Deposit is requested within Connect.
onAuthDepositVerify function A callback function triggered when an Auth Deposit is verified manually through Connect.
topInstitutions string Choose what type of institutions, if any, will be displayed in the Top Institutions portion of the institution select screen. Possible values are banks, brokerages, all, or none. This parameter is optional and will default to all.
syncType string Choose what type of connection syncs are performed within Connect. Possible values are agg, auth, or both, which will simultaneously run an agg AND auth sync on new connections. This parameter is optional and will default to agg. More information on integrating account verification with Connect can be found here.
search object Use the search parameter to customize the institution search page in Connect. See below for fields in the search object.
singleSync boolean If true, the “Connect Another Account” button will be hidden. This button appears once a connection has been successfully synced to prompt the User to add any additional connections they may have. This parameter is optional and will default to false.
userCss string If you would like to override our default styling and use your own CSS rule sets, pass the full URL of your publicly available stylesheet, e.g., https://example.com/your-custom-stylesheet.css
confirmClose bool A screen asking the user to confirm that they’d like to close the Connect widget will be presented when the “close” icon is clicked. Defaults to true.
subdomain string Alternate location for the Connect widget source. Only select integrations coordinated with Quovo will require the use of this parameter. Contact us if you’d like to learn more.
enableAuthDeposits boolean If true, the Auth Deposits workflow will be enabled within Connect. This lets end users verify their bank accounts on any institution not covered by instant account verification. Note: This workflow is not available by default. Contact us if you would like access to Auth Deposits within Connect.

search Object

Field Type Description
results string Choose which institutions should be available in Connect’s institution search. Possible values are all and auth. If auth is selected, only institutions that currently support instant account verification will be searchable. This parameter is optional and will default to all.
filteredInstitutions string Determines how institutions filtered out by the results rule are displayed. Possible values are hidden and disabled. If hidden is selected, filtered institutions will not be shown in the search results. If disabled is selected, filtered institutions will appear grayed out in the search results. This parameter is optional and will default to hidden.
testInstitutions boolean If true, Quovo test institutions will be searchable within Connect. Note: this field can also be passed directly to Quovo.create for backwards-compatibility, however the value defined here in the search object will take precedence.
function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    onLoad: function() {
      // Connect will open immediately after it is done loading.
      handler.open();
    },
  });
}

getConnectToken(setupConnect);

onAdd, onSync and onAuthenticate

While callbacks like onLoad or onClose are triggered by the Connect widget itself, onAdd, onSync and onAuthenticate are triggered by user actions inside of Connect. Using these callbacks, you can trigger actions anytime a user adds or syncs a connection, providing a more responsive integration with Connect.

onAdd, onSync and onAuthenticate will either be passed an err argument, alerting developers to issues that Connect may have encountered; or an event argument, containing the results for the appropriate event.

{
  "connection": {
    "id": 2135634,
    "institutionId": 34,
    "userId": 1123
  },
  "timeStamp": 1496879583157
}

onAdd

onAdd(err, event) will be triggered anytime a Quovo connection is created within Connect. event is an object containing:

event Object

Name Type Description
connection object The details of the Quovo connection that was just added. See below for fields in the connection object.
timeStamp integer A timestamp of when the event was generated. This is given in Unix epoch time in milliseconds.

connection Object

Name Type Description
id integer The new connection’s Quovo ID.
institutionId integer The institution ID of the new connection.
userId integer The ID of the Quovo User that added the connection.
{
  "connection": {
    "id": 2135634,
    "institutionId": 34,
    "userId": 1123
  },
  "sync": {
    "authenticated": false,
    "connectionId": 2135634,
    "status": "challenges"
  },
  "timeStamp": 1496879583157
}

onSync

onSync(err, event) will be triggered every time a connection is synced through Connect. event is an object containing:

event Object

Name Type Description
connection object The details of the Quovo connection that was just synced. See below for fields in the connection object.
sync object The results of the sync that just completed. See below for fields in the sync object.
timeStamp integer A timestamp of when the event was generated. This is given in Unix epoch time in milliseconds.

connection Object

Name Type Description
id integer The new connection’s Quovo ID.
institutionId integer The Quovo institution ID of the new connection.
userId integer The ID of the Quovo User that added the connection.

sync Object

Name Type Description
authenticated bool This field indicates whether the connection has been successfully authenticated by the target institution. If it is true, then the credentials and MFA answers on the connection were entered correctly.
connectionId integer The ID of the Quovo connection that the sync was performed on.
status string The final sync status of an attempted sync. If a connection has been successfully authenticated, this value may be null.

onAuthenticate

onAuthenticate(err, event) will be triggered anytime a connection is successfully authenticated within Connect (but possibly before the sync process has finihsed). event is an object containing:

event Object

Name Type Description
connection object The details of the Quovo connection that was just authenticated. See below for fields in the connection object.
timeStamp integer A timestamp of when the event was generated. This is given in Unix epoch time in milliseconds.

Preselect an Institution

handler.open({
  // Connect will bypass the search page and open directly to the page to
  // add a "Fidelity NetBenefits" connection (which has an Institution ID of 23).
  institutionId: 23,
});

You may want to direct users to add connections onto specific institutions. With Connect, you can preselect an institution for users and bypass the search page entirely.

Pass an object to the open method on the Connect handler. institutionId should be an available field, with the desired Institution ID as the value.

Update or Resolve Issues on an Existing Connection

handler.open({
  // Connection 813981 has a status of "challenges", so Connect will open to a
  // page where the user can answer any outstanding MFA questions and resync
  // the connection accordingly.
  connectionId: 813981,
});

You may want users to update or resolve issues on existing connections. They may need to supply additional MFA answers or update recently changed login credentials. With Connect, you can simply pass a connection ID to direct users to fix these issues, allowing their connections to continue syncing. Connections with an “incorrect_credentials” status will be taken to a screen where users can update their credentials, while connections with a “challenges” status will be taken to a screen where users are prompted to answer additional MFA questions.

If both connectionId and institutionId arguments are supplied to handler.open, the connectionId workflow will take priority.

Custom CSS

Override/Helper Classes

Using an additional custom stylesheet can be tough to implement, considering it’s being applied on top of rules already set up by Quovo for Connect components. To that end, we’ve included some override rules to allow easier access to the elements we consider ‘high-impact’ for branding and user experience.

It’s important to remember that while this list will help you quickly change critical elements, it will not cover every item throughout Connect. You can inspect indivial elements and apply rules in your custom rule sheet to anything you’d like.

Class Name Description
q-search-icon Blue magnifying class icon on the institution search screen
q-institution-card Blue background on the hover state of institution cards
q-request-background Blue background on the left side of the request institution screen
q-connection-background Blue background on the left side of all connection screens, expanding to a full-screen background on syncing and request screens
q-info-icon Blue ‘i’ information icon on connection screens
q-button Generic gray buttons throughout the app

Confirm Close Modal: This is the screen reading “Done Adding Accounts” including “Done” and “Cancel” buttons, that by default appears when a user clicks the upper right “X” in the Connect Widget

Class Name Description
q-button-close-cancel Transparent ‘Cancel’ button
q-button-close-done Blue ‘Done’ button

Custom Fonts via userCss

@font-face {
  font-family: 'myCustomFont';
  src: url('http://example.com/assets/fonts/Custom-font.ttf') format('truetype');
  font-weight: normal;
  font-style: normal;
}

#specific-connect-element {
  font-family: 'myCustomFont';
}

You may wish to include custom fonts in your userCss stylesheet to better align Connect with your brand experience. Including remotely located font files can be done by using the @font-face at-rule.

For more information, you can check out the following resources:

Auth

Verifying ownership of a financial account is an important part of initiating payments and transfers. Quovo’s Auth API provides valuable information about a financial account - type, routing and account numbers, and balance - in order to confirm that a user is in fact the owner of that account. Connect can seamlessly integrate with the Auth API, letting your users run authentication syncs on new connections linked through Connect.

Auth Syncs in Connect

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    topInstitutions: 'banks',
    syncType: 'auth',
  });
}

getConnectToken(setupConnect);

To enable account verification syncs within Connect, pass the parameter syncType with a value of 'auth' to the Connect handler. If you would like to trigger both aggregation and authentication syncs on new connections, pass syncType with a value of 'both' to the Connect handler.

Aggregation syncs vs Auth syncs

Aggregations syncs are a complete fetch of any available data within an account. They will yield historical transactions, current holdings, and more. By default, any account with aggregation enabled will also be included in our nightly sync process, during which connections are automatically synced by Quovo.

Authentication syncs are specifically for account verification. They will yield sub-account-specific information such as routing and account numbers. Unlike aggregation syncs, authentication syncs are only run on demand. Auth-only connections will not be included in our nightly sync process.

Filtering Out Non-Auth Institutions

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    topInstitutions: 'banks',
    search: {
      results: 'auth',
      filteredInstitutions: 'disabled',
      testInstitutions: false,
    },
    syncType: 'auth',
  });
}

getConnectToken(setupConnect);

When integrating Auth syncs with Connect, you may want to restrict the institution list available within Connect so that your users only see the institutions that support instant account verification. The search field in the Quovo.create configuration object allows you to modify the institution search page to fit your needs. The available fields in the search object are:

Field Type Description
results string Choose which institutions should be available in Connect’s institution search. Possible values are all and auth. If auth is selected, only institutions that currently support instant account verification will be searchable. This parameter is optional and will default to all.
filteredInstitutions string Determines how institutions filtered out by the results rule are displayed. Possible values are hidden and disabled. If hidden is selected, filtered institutions will not be shown in the search results. If disabled is selected, filtered institutions will appear grayed out in the search results. This parameter is optional and will default to hidden.
testInstitutions boolean If true, Quovo test institutions will be searchable within Connect. Note: this field can also be passed directly to Quovo.create, however, the value defined in the search object will take precedence.

Auth Deposits

Quovo provides Auth Deposit verification for any institution not covered by instant account verification. Auth Deposits leverage Quovo account aggregation to automatically verify that microdeposits (sent by Quovo) have cleared at a specified bank account.

After initiating the Auth Deposit process, Quovo will deposit two small amounts into the targeted bank account. By checking the relevant bank account’s transaction history, Quovo will automatically verify whether or not the microdeposits went through. This facilitates a smoother account verification workflow, less dependent on end user confirmation. However, if you would like to enforce end user confirmation in your workflow, you may still manually verify the Auth Deposits.

Enable Auth Deposits in Connect

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    topInstitutions: 'banks',
    enableAuthDeposits: true,
  });
}

getConnectToken(setupConnect);

To enable Auth Deposits in Connect, pass enableAuthDeposits: true as a key-value pair in the Quovo.create configuration object. Connect will then use Auth Deposits as a fallback for any institution that does not currently support instant account verification.

After prompting the user to link their connection with login credentials, Connect will decide whether to trigger the Auth Deposit-workflow depending on the institution’s Auth capabilities. If the institution supports instant account verification, the newly added connection’s authentication details will be immediately available. If the institution is not eligible for instant account verification, the user will begin the the Auth Deposit process, during which the user will be prompted to enter their account and routing number. Quovo will handle the rest both by transferring microdeposits to the target bank account and by verifying that those microdeposits actually reach the account.

If you would like to check the status of ongoing Auth Deposits, you can call our /auth_deposits endpoint.

Send Auth Deposits to an Existing Connection

handler.open({
  // Connection 813981 has a status of "challenges", so Connect will open to a page
  // where the user can answer any outstanding MFA questions and resync the
  // connection. Once the connection has a status of "good" the user will be prompted
  // to enter their account and routing numbers to complete the auth deposit workflow.
  connectionId: 813981,
});

If you would like to initiate the Auth Deposit flow on an existing connection, pass connectionId: {{ connectionId }} to handler.open(). As with the other Auth Deposit workflows, be sure to pass enableAuthDeposits as true to the Quovo.create configuration object.

You can target both connections that have failed previous Auth Deposit attempts as well as connections that have never sent an Auth Deposit. If the connection’s status is not "good", the user will be first taken to a screen where they can update their credentials or answer additional MFA questions. Once the connection has a status of "good", the Auth Deposit workflow will be initiated.

Verify Auth Deposits

handler.open({
  // Account 1234567 has an auth deposit status of "transferred", so Connect
  // will open to a page where the user can enter the Auth Deposit amounts sent
  // by Quovo.
  accountId: 1234567,
  verifyAuthDeposits: true,
});

Once the microdeposits have been sent, i.e. the Auth Deposit has a status of "submitted", the end user may manually verify the Auth Deposit.

It may take 3-4 business days for the deposits to appear in the target bank account, so be sure to make the messaging clear to your end users that they must check their bank accounts over the next few days. You can also wait to message the end user until after the Auth Deposit’s status has been updated to “transferred”. This better ensures the micro-deposit is currently visible in the target bank account when you notify the end user about their ongoing Auth Deposit.

Once your end users are ready to verify the microdeposits, pass verifyAuthDeposits as true along with accountId: {{ accountId }} to the handler.open() function. As with the other Auth Deposit workflows, be sure to pass enableAuthDeposits as true to the Quovo.create configuration object.

Errors

try {
  handler.open({
    institutionId: 'bank of america',
  });
} catch (err) {
  if (err instanceof Quovo.InputError) {
    console.error('Invalid input type given to handler.open().');
  }
}
try {
  handler.open({
    institutionId: 'bank of america',
  });
} catch (err) {
  if (err instanceof Quovo.ConnectError) {
    console.error('A Connect-related exception has been raised.');
  } else {
    console.error('A non-Connect-related exception has been raised.');
  }
}

The Connect library provides a suite of detailed exceptions to help identify possible implementation issues. All of these custom error classes are bound to the top level of the Quovo object. These custom errors include:

Error Description
ConnectError The generic error type thrown by Connect. This exact exception will never be raised directly, but the rest of the errors listed here are subclasses of ConnectError. You can check for ConnectError to have a catch-all for any exceptions raised by Connect.
EventOriginError Raised when Connect detects a mismatch between the current host and the host that called Quovo.create.
InputError Raised when arguments given to any of Connect’s methods aren’t valid. More details on the invalid parameter will be provided in the error message when thrown.
TimingError Raised when Connect receives a request to open before it finishes loading. We suggest utilizing the onLoad callback argument taken by Quovo.create() to ensure Connect has finished loading before attempting to open it.
TokenError Raised when the access token provided to Connect is missing or invalid.
ElementNotFoundError Raised when the element ID given to Connect can not be located.

PFM

You can easily integrate Quovo’s suite of prebuilt Personal Finance modules directly into your application’s layout. These modules allow you to leverage the account data aggregated by Quovo Connect or through the Quovo API to provide unique insights and visualizations to your users. Getting started with our modules takes just a few minutes, and is described in the documentation below.

Integration

<div id="quovo-accounts-module"></div>
<div id="quovo-allocation-module"></div>

<!-- iframes will fit their parent element's dimensions -->
<style>
  #quovo-accounts-module,
  #quovo-allocation-module {
    height: 400px;
    width: 600px;
  }
</style>

<script>
  document.addEventListener('DOMContentLoaded', embedModules, false);

  function embedModules() {
    // two separate access tokens, one for each module.
    const token1Promise = getQuovoToken(523479);
    const token2Promise = getQuovoToken(523479);

    // resolve tokens and embed modules
    Promise.all([token1Promise, token2Promise]).then(promiseValues => {
      Quovo.embed({
        token: promiseValues[0],
        elementId: 'quovo-accounts-module',
        moduleName: 'accounts',
      });

      Quovo.embed({
        token: promiseValues[1],
        elementId: 'quovo-allocation-module',
        moduleName: 'allocation',
      });
    }, err => {
      // console.log(err);
    });
  }
</script>

After loading the ui.js script, the Quovo library will be available as the Javascript variable Quovo (or window.Quovo). Call Quovo.embed to both create an active iframe. (In the example to the right, getQuovoToken is an asynchronous function that fetches a user-specific access token. Since this function depends on the structure of your server-side code, it is not defined here.)

The available parameters to Quovo.embed are:

Field Type Description
token string [required] A user-specific access token. This is used to authenticate the user and gain access to the embedded module.
elementId string [required] The ID of the DOM element meant to hold the embedded Quovo module iframe.
moduleName string [required] The name of the Quovo module to be embedded. Available modules include accounts, account-details, holdings, transactions, allocation, spending, net-worth, goals, and summary. Alternatively, you can use the value dashboard to embed the full app with navigation.
account integer The ID of a Quovo account. This parameter is only used to specify a target account when opening the account-details module, and will be ignored otherwise.
userCss string If you would like to override our default styling and use your own CSS rule sets, pass the full URL of your publicly available stylesheet, e.g., https://example.com/your-custom-stylesheet.css
subdomain string Alternate location for the embedded widget source. Only select integrations coordinated with Quovo will require the use of this parameter. Contact us if you’d like to learn more.
onLoad function A callback function triggered after the embedded module is done loading.
onActivity function A callback function triggered after a user performs activity (i.e. clicking) within the app.
onAdd function A callback function triggered anytime a Quovo connection is created within Connect.
onDelete function A callback function triggered when a connection is deleted by the user.
onSync function A callback function triggered when a connection is synced through Connect.
onUpdate function A callback function triggered when a change is made by the user to an Account. These changes include editing or adding an Account nickname, changing the Account’s type, or disabling/enabling an Account.

Callbacks

{
  "connection": {
    "id": 2135634,
    "institutionId": 34,
    "userId": 1123
  },
  "timeStamp": 1496879583157
}

Using callback parameters, you can trigger actions anytime a user adds, deletes, syncs, or updates a connection, providing a more responsive integration.

These callbacks work with all embedded modules:

Field Type Description
onLoad function A callback function triggered after the embedded module is done loading.
onActivity function A callback function triggered after a user performs activity (i.e. clicking) within the app.

Accounts Callbacks

Additionally, these callbacks work with the Accounts module to enable actions on connection-related events:

Field Type Description
onAdd function A callback function triggered anytime a Quovo connection is created within Connect.
onDelete function A callback function triggered when a connection is deleted by the user.
onSync function A callback function triggered when a connection is synced through Connect.
onUpdate function A callback function triggered when a change is made by the user to an Account. These changes include editing or adding an Account nickname, changing the Account’s type, or disabling/enabling an Account.

Custom CSS

Field Type Description
userCss string If you would like to override our default styling and use your own CSS rule sets, pass the full URL of your publicly available stylesheet, e.g., https://example.com/your-custom-stylesheet.css

Override/Helper Classes

Using an additional custom stylesheet can be tough to implement, considering it’s being applied on top of rules already set up by Quovo for the embedded component. To that end, we’ve included some override rules to allow easier access to the elements we consider ‘high-impact’ for branding and user experience.

It’s important to remember that while this list will help you quickly change critical elements, it will not cover every item throughout Quovo’s embedded components. You can inspect indivial elements and apply rules in your custom rule sheet to anything you’d like.

Download the PDF Guide here.

Custom Fonts via userCss

@font-face {
  font-family: 'myCustomFont';
  src: url('http://example.com/assets/fonts/Custom-font.ttf') format('truetype');
  font-weight: normal;
  font-style: normal;
}

#specific-element {
  font-family: 'myCustomFont';
}

You may wish to include custom fonts in your userCss stylesheet to better align Quovo’s modules with your brand experience. Including remotely located font files can be done by using the @font-face at-rule.

For more information, you can check out the following resources:

Fetching Connections

Getting Data for Added Connections

curl -X GET -H "Authorization: Bearer a724809d37d0a21b7e9257f45cee416f5aec61993ab4b09e" "https://api.quovo.com/v3/users/523479/connections"
{
  "connections": [
    {
      "config_instructions": null,
      "created": "2016-03-26T13:45:00Z",
      "id": 877247,
      "institution_id": 21534,
      "institution_name": "Test Investment Institution",
      "is_disabled": false,
      "last_good_sync": "2018-03-28T14:00:40Z",
      "last_sync": "2018-03-28T14:00:40Z",
      "status": "good",
      "user_id": 162703,
      "username": "quovo_test_user",
      "value": 73479.096133
    },
    {
      "config_instructions": null,
      "created": "2016-03-28T16:58:30Z",
      "id": 877504,
      "institution_id": 21700,
      "institution_name": "Test Bank Institution",
      "is_disabled": false,
      "last_good_sync": "2018-03-28T16:58:30Z",
      "last_sync": "2018-03-28T16:58:30Z",
      "status": "good",
      "user_id": 162703,
      "username": "quovo_test_user",
      "value": 1744.14
    }
  ]
}

Once a user is finished updating or connecting their financial accounts, you can get information on the added connections through the Quovo API.

To view all of the user’s connections, make a GET request to https://api.quovo.com/v3/users/{user_id}/connections, where {user_id} is the id of the Quovo user. Once you have the connections, you can use the created field to tell if they have been added recently or not.

Using Webhooks

In addition to calling the Quovo API, you can also register webhooks prior to users linking their connections. Your registered endpoints will then be notified any time a user adds a Quovo connection or when that connection finishes syncing.