Add VoPay to your app

Use VoPay with Plaid Auth to send and receive payments!


Overview

VoPay is a leader in payment innovation, digitizing direct bank payments with speed and transparency. The VoPay Platform enhances how digital platforms initiate and accept financial transactions using a single, open API. The company has one goal: to eliminate all payment inefficiencies, so businesses can focus on what they do best in today’s fast-paced digital economy. VoPay’s EFT / ACH payment service adds a layer of data intelligence to EFT / ACH transactions to make them instant. With the Plaid integration, VoPay will validate and authenticate bank account information at the time of the transaction

To get started sign up for Plaid API keys.

Getting Started

You'll first want to familiarize yourself with Plaid Link, a drop-in client-side integration for the Plaid API that handles input validation, error handling, and multi-factor authentication. You will also need to have a verified VoPay account to add a bank funding source.

Your customers will use Link to authenticate with their financial institution and select the bank account they wish to use for payment transactions. From there, you'll receive a Plaid access_token and a VoPay processor_token, which allows you to quickly and securely verify a bank funding source via VoPay's API without having to store any sensitive banking information. Utilizing Plaid + VoPay enables a seamless workflow for sending and receiving payments.

Instructions

Set up your accounts

You'll need accounts at both Plaid and VoPay in order to use the Plaid + VoPay integration. You'll also need to enable your Plaid account for the VoPay integration.

First, you will need to work with the VoPay team to sign up for a VoPay account, if you do not already have one.

Next, verify that your Plaid account is enabled for the integration. If you do not have a Plaid account, create one.

To enable your Plaid account for the integration, go to the Integrations section of the account dashboard. If the integration is off, simply click the 'Enable' button for VoPay to enable the integration.

Create a link_token

In order to integrate with Plaid Link, you will first need to create a link_token. A link_token is a short-lived, one-time use token that is used to authenticate your app with Link. To create one, make a /link/token/create request with your client_id, secret, and a few other required parameters from your app server. For a full list of link_token configurations, see /link/token/create.

To see your client_id and secret, visit the Plaid Dashboard.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const plaid = require('plaid');
const client = new plaid.Client({
clientID: process.env.PLAID_CLIENT_ID,
secret: process.env.PLAID_SECRET,
env: plaid.environments.sandbox,
});
app.post('/create_link_token', async (request, response) => {
try {
// Get the client_user_id by searching for the current user
const user = await User.find(...);
const clientUserId = user.id;
// Create the link_token with all of your configurations
const tokenResponse = await client.createLinkToken({
user: {
client_user_id: clientUserId,
},
client_name: 'Plaid Test App',
products: ["auth"],
country_codes: ['US'],
language: 'en',
webhook: 'https://webhook.sample.com',
});
response.json(tokenResponse);
} catch (e) {
// Display error on client
return response.send({ error: e.message });
}
});
Integrate with Plaid Link

Once you have a link_token, all it takes is a few lines of client-side JavaScript to launch Link. Then, in the onSuccess callback, you can call a simple server-side handler to exchange the Link public_token for a Plaid access_token and a VoPay processor_token.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<button id="linkButton">Open Link - Institution Select</button>
<script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
<script>
(async function(){
var linkHandler = Plaid.create({
// Make a request to your server to fetch a new link_token.
token: (await $.post('/create_link_token')).link_token,
onSuccess: function(public_token, metadata) {
// The onSuccess function is called when the user has successfully
// authenticated and selected an account to use.
//
// When called, you will send the public_token and the selected account ID,
// metadata.accounts, to your backend app server.
sendDataToBackendServer({
public_token: public_token,
accounts: metadata.accounts
});
},
onExit: function(err, metadata) {
// The user exited the Link flow.
if (err != null) {
// The user encountered a Plaid API error prior to exiting.
}
// metadata contains information about the institution
// that the user selected and the most recent API request IDs.
// Storing this information can be helpful for support.
},
});
})();
// Trigger the authentication view
document.getElementById('linkButton').onclick = function() {
// Link will automatically detect the institution ID
// associated with the public token and present the
// credential view to your user.
linkHandler.open();
};
</script>

See the Link parameter reference for complete documentation on possible configurations.

Plaid.create accepts one argument, a configuration Object, and returns an Object with three functions, open, exit, and destroy. Calling open will display the "Institution Select" view, calling exit will close Link, and calling destroy will clean up the iframe.

Write server-side handler

The Link module handles the entire onboarding flow securely and quickly, but does not actually retrieve account data for a user. Instead, the Link module returns a public_token and an accounts array, which is a property on the metadata object, via the onSuccess callback. Exchange this public_token for a Plaid access_token using the /item/public_token/exchange API endpoint.

The accounts array will contain information about bank accounts associated with the credentials entered by the user, and may contain multiple accounts if the user has more than one bank account at the institution. If you want the user to specify only a single account to link so you know which account to use with VoPay, set Select Account to "enabled for one account" in the Plaid Developer Dashboard. When this setting is selected, the accounts array will always contain exactly one account.

Once you have identified the account you will use, you will send the access_token and account_id property of the account to Plaid via the /processor/token/create endpoint in order to create a VoPay processor_token. You'll send this token to VoPay and they will use it to securely retrieve account and routing numbers from Plaid.

You can create VoPay processor_tokens in all three API environments:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Change sandbox to development to test with live users and change
// to production when you're ready to go live!
const plaid = require('plaid');
const plaidClient = new plaid.Client({
clientID: process.env.PLAID_CLIENT_ID,
secret: process.env.PLAID_SECRET,
env: plaid.environments.sandbox,
});
try {
const exchangeTokenResponse = await plaidClient.exchangePublicToken(
publicToken,
);
const accessToken = exchangeTokenResponse.access_token;
// Create a processor token for a specific account id.
const processorTokenResponse = await plaidClient.createProcessorToken(
accessToken,
accountId,
'vopay',
);
const processorToken = processorTokenResponse.processor_token;
} catch (err) {
// handle error
}

For a valid request, the API will return a JSON response similar to:

1
2
3
4
{
"processor_token": "processor-sandbox-0asd1-a92nc",
"request_id": "m8MDnv9okwxFNBV"
}

For possible error codes, see the full listing of Plaid error codes.

Launching to Production

Test with Sandbox credentials

To test the integration in Sandbox mode, simply use the Plaid Sandbox credentials along when launching Link with a link_token created in the Sandbox environment.

When testing in the Sandbox, you have the option to use the /sandbox/public_token/create endpoint instead of the end-to-end Link flow to create a public_token. When using the /sandbox/public_token/create-based flow, the Select Account flow will be bypassed and the accounts array will not be populated. On Sandbox, instead of using the accounts array, you can call /accounts/get and test with any returned account ID associated with an account with the subtype checking or savings.

Get ready for production

Your account is immediately enabled for our Sandbox environment (https://sandbox.plaid.com). To move to Production, please request access from the Dashboard. You will need VoPay Production credentials prior to initiating live payment transactions in the VoPay API with Plaid.

Support and questions

Find answers to many common integration questions and concerns—such as pricing, sandbox and test mode usage, and more, in our docs.

If you're still stuck, open a support ticket with information describing the issue that you're experiencing and we'll get back to you as soon as we can.