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 v2

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.

Integration Setup

<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,
      // subdomain parameter required for connect v2
      subdomain: "connect2",
      // 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>

Connect requires creating a button or link in your interface that users will launch the Connecting widget as a modal that will overlay the existing page.

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.)

landing desktop view landing mobile view

The subdomain parameter for Quovo.create is:

Field Type Description
subdomain string Parameter required to be connect2 for the Connect v2. Note: If this parameter is not set, app defaults to Connect v1 connect

Sync Types

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    syncType: "aggBoth"
  });
}

After users successfully connect their accounts, Connect will retrieve information on behalf of the user in one of the following types of syncing:

Aggregations syncs fetch balances, holdings, and transaction-level data across all account types. The level of detail will depend largely on the type of account that is being returned. For example personal finance accounts (checking, savings) will have fewer holdings than a investment accounts (brokerage, IRA, 401k, etc) which may have fluctuating prices and asset classes. For full overview of all the data available using aggregation, click here. Connect will pull in all available transactions on each account. While it depends on the institution, most of our accounts will receive transactions dating back more than a year.

To enable account verification syncs within Connect, pass the parameter syncType with a value of 'agg' to the Connect handler. 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 verifying ownership of account as 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 account (although the exact fields returned can vary by country).

To enable account authentication verification syncs within Connect, pass the parameter syncType with a value of 'auth' to the Connect handler. Unlike aggregation syncs, authentication syncs are only run on demand. Auth-only connections will not be included in our nightly sync process.

Both Syncs For some use cases, you may want to have collect information from both an account authentication and aggregation sync. Connect has specific screen flows that are configured for agg vs auth sync types (see screen flows below) and you will need to define which is the primary workflow for your users.

To enable Both syncs with users getting the screen flow with account authentication within Connect, pass the parameter syncType with a value of 'authBoth' to the Connect handler.

To enable Both syncs with users getting the screen flow with account aggregation within Connect, pass the parameter syncType with a value of 'aggBoth' to the Connect handler.

By default, any account with syncType with a value of 'aggBoth' or 'authBoth' enabled will also be included in our nightly sync process, during which connections are automatically synced by Quovo.

Screen Flows and Configurations

Landing

When you first launch Connect, your users will be presented with a landing screen that allows them to select from a preselected list of top institutions or depending on your use case configure using your own top institution list (get full list of available institutions here), see below for areas of the screen that can be configured.

landing custom css

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    topInstitutions: "banks"
  });
}
function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    topInstitutions: "[1249,1209,2779,2782]"
  });
}

The available parameters for the Landing screen using Quovo.create are:

Field Type Description
topInstitutions string Choose what type of institutions will be displayed in the Top Institutions portion of the institution select screen. Possible values are banks, brokerages, all, or none. Note, you can also enter your own list of top institutions by entering array of institutionId. This parameter is optional and will default to all.
headerText string Choose what the global header text. This parameter is optional and will default to Connect Accounts.
subHeaderText string Choose what sub-global header text. This parameter is optional and will default to being empty.
hideHeader boolean Choose whether to show the header and subheader. If true, the header and subheader will be hidden. This parameter is optional and will default to false.
showManualAccounts boolean Choose whether the “Enter Manually” displays at bottom of landing page & search results. If false, this section will be hidden. This parameter is optional and will default to true. Note the elements within Manual Account can be configured using the manualAccounts object below.
onLoad function A callback function triggered after Connect is done loading.
onOpen function A callback function triggered every time Connect is opened.
function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    manualAccounts:{
        headerText: 'Header Text',
        linkText: 'Link Text',
        linkURL: 'http://quovo.com'
      }
  });
}

The available fields in the manualAccounts object are:

Field Type Description
headerText string Configure text for “Can’t find what you need?”. This parameter is optional and will default to text above.
linkText string Configure text for “ENTER MANUALLY”. This parameter is optional and will default to text above.
linkURL string By default this is set to false and when clicking the text “Enter Manually”, the user is taken to enter account manually. If you want to keep the Manual Accounts CTA but would prefer to re-direct your users to your own UI, enter url and clicking on linkText will re-direct to the url entered.

Search Results

After you starting typing more than 3 characters, Connect will start to display the top results curated by our search algorithm which analyzes relative popularity of institutions, url domains, and among other things. Results are displayed showing institution logo, name, and url domains.

search result view

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    search:{
       testInstitutions: true
      }
  });
}

search result custom css

Filtering Out Non-Auth Institutions

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.

search result for non-auth accounts

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.

Enter Credentials

After selecting an institution from the Landing page or Search Results, you will be taken to enter your Credentials.

enter credential custom css

The available parameters for the Enter Credentials screen using Quovo.create:

Field Type Description
credsNotice string Configure what text appears below the Institution Logo and url, empty by default.
hideTerms boolean Defaults to false, setting to true will hide the Quovo terms of User and Privacy Policy.
enterCredsButtonText string Configure what text appears for the Primary Action Button, defaults to “Connect Accounts”

The available fields in the credsLearnMore object are:

Field Type Description
isHidden boolean Defaults to false, setting to true will hide the “We use bank-level encryption to keep your data secure. Learn More”
infoMessage string Configure text for “We use bank-level encryption to keep your data secure. Learn More”. This parameter is optional and will default to text above.
learnMoreText string Configure text for “Learn More”. This parameter is optional and will default to text above.
learnMoreUrl string By default this is set to false and when clicking the text “Learn More”, you will be re-directed to https://www.quovo.com/infosec/. Configure by entering url into this parameter.

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 “wrong_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.

Agg Syncing Workflow

If you have elected syncType agg or aggboth, then your users will get the following Syncing Steps.

Step 1 - Authenticating

After user enters credentials, we are authenticating with the institution which may result in having to provide complete multi-factor authentication, for more info on our specific sync workflows, click here. After we have verified the credentials, we begin retrieving data.

Step 2 - Getting Account Data

Now, Connect is retrieving full balances, holdings, and transaction-level data across all accounts within the institution. Note: If the user doesn’t want to wait for the full sync to finish, we allow them to “Add Another” which will take them back to the Landing screen to continue syncing more accounts or “Done” which will close connect modal.

Step 3 - Playback

After the connection has finished syncing, Connect will show a summary of the account names, account types, and balances that were retrieved. Again the user can either select “Add Another” or select “Done” to exit the modal.

playback gif for agg sync

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    closeOnAuthentication:true
  });
}

The available parameters for the Auth syncing workflow using Quovo.create:

Field Type Description
closeOnAuthentication boolean Defaults to false, setting to true will exit Connect after sync has finished authenticating.
closeOnSync boolean Defaults to false, setting to true will exit Connect after sync has finished gathering data.

Auth Syncing Workflow

If you have elected syncType auth or authboth, then your users will get the following Syncing Steps.

Step 1 - Authenticating

After user enters credentials, we are authenticating with the institution which may result in having to provide complete multi-factor authentication, for more info on our specific sync workflows, click here. After we have verified the credentials, we begin retrieving data.

Step 2 - Account Selection

Connect has finished retrieving the account ownership data and will present users with list of accounts showing name, type, and balance so that they can select account they would like to designate for money movement. Note, only Checking and Saving account types will be eligible for selection. All other account types will be grouped under “Not available for connection”. Users can Change Account Type if they believe an accounts has been miscategorized.

account selection view for auth sync

Step 3 - Playback

After the user has finished selecting an account, Connect will show a summary of the only account selected. Note, all the account info is still available for all accounts within the connection via our api.

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    closeOnAuthentication:true
  });
}
function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    closeOnAuthSelection:true
  });
}

The available parameters for the Auth syncing workflow using Quovo.create:

Field Type Description
closeOnAuthentication boolean Defaults to false, setting to true will exit Connect after sync has finished authenticating.
closeOnAuthSelection boolean Defaults to false, setting to true will exit Connect after user has finished selecting account.
closeOnSync boolean Defaults to false, setting to true will exit Connect after sync has finished gathering data.

Single Sync

Connect can be configured to launch with the ability to remove access to the search and landing screens keeping user focused on completing one connection.

The available parameters for the Single sync using Quovo.create:

Field Type Description
singleSync boolean Defaults to false, setting to true will remove the back arrow on the top left. “Add Another” button will be hidden during the syncing workflow and the playback steps.

Tray

As soon as users sync one or more institutions using Connect, there will be a persistent “Tray” located on the top of Connect that allows users to manage and take actions on all connections associated with a user. It will display “Needs Attention” if there are accounts that require user action to resolve.

landing page with tray gif

function setupConnect(token) {
 var handler = Quovo.create({
   token: token,
   hideTray:true
 });
}

The available parameters for the Tray using Quovo.create:

Field Type Description
hideTray boolean Defaults to false, setting to true will hide the Tray

Exiting Connect

Upon exiting Connect, the user is presented with “Are you sure that you are finished connecting accounts?” prompt by default.

close speedbump view

function setupConnect(token) {
  var handler = Quovo.create({
    token: token,
    confirmClose:true
  });
}

The available parameters for the Exiting Connect using Quovo.create:

Field Type Description
confirmClose boolean Defaults to true, setting to false will hide the prompt asking the user to confirm that they’d like to close the Connect Widget will be presented when the “close” icon is clicked.

Timestamp Formats

Connect shows the last updated timestamp next to connections within the Tray and after a successful connection in time ago format, e.g. 43 minutes ago, 18 hours ago, 3 Days ago, etc.

account cards with time ago timestamp

If you want to show a full date and time in the timestamp, you can switch formats by passing true to the useAbsoluteDate parameter.

account cards with absolute timestamp

The available parameters for the Timestamps using Quovo.create:

Field Type Description
useAbsoluteDate boolean Defaults to false and show last updated timestamp in “time ago format”. Setting to true will show last updated timestamp with full date and time.

Callbacks

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

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 when a Quovo connection is created within Connect.
onDelete function A callback function triggered when a connection is deleted 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.
onAuthAccountSelected function A callback function triggered when an account is selected and will contain the selected account info. Note: This parameter only apply with syncType equal to auth or authBoth.

onAdd, onDelete, onSync, onAuthenticate, and onAuthAccountSelected

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

onAdd, onDelete, onSync, onAuthenticate and onAuthAccountSelected 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
}

onDelete

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

event Object

Name Type Description
connection object The details of the Quovo connection that was just deleted. 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 deleted connection’s Quovo ID.
institutionId integer The institution ID of the deleted connection.
userId integer The ID of the Quovo User that deleted the connection.

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 synced connection’s Quovo ID.
institutionId integer The Quovo institution ID of the synced connection.
userId integer The ID of the Quovo User that synced 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 one of the values in the table below. If a connection has been successfully authenticated, this value may be null.
Status Description Requires User Action
good The connection was properly synced. false
wrong_credentials The login credentials for the connection are incorrect. true
challenges There are additional MFA challenges that need to be answered. true
user_config The institution requires the end user to log into the connection and resolve an issue. These instructions are institution-specific, and can be found in config_instructions on a connection object. true
resync The connection needs to be resynced to complete the sync process, usually because a time-sensitive challenge has expired. true
postponed The institution is inaccessible at the moment. Quovo will attempt another sync at the end of the day. false
maintenance There were Quovo-side issues while syncing the connection. false
no_accounts There were no accounts found within the connection. false
institution_unavailable Quovo is temporarily unable to sync any connections at this institution. false
oauth The first of two syncs required by the OAuth workflow has been completed, and the sync is awaiting user redirection to your URL in order to resync and resolve in an end status. true
(null value) The connection was created, but no sync attempt has been completed. false

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.

connection Object

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

onAuthAccountSelected

{
    "account":{
        "connectionId": 10805823,
        "id": 58664719,
        "userId": 6651859
    },
    "timestamp": 1552497526067
}

onAuthAccountSelected(err, event) will be triggered when an account is selected during an auth sync and will contain the selected account info. event is an object containing:

event Object

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

account Object

Name Type Description
id integer The new account’s ID.
connectionId integer The authenticated connection’s Quovo ID.
userId integer The ID of the Quovo User that added the connection.

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.