Home / Issuing / Quick Start Templates
Commercial prepaid card products allow businesses to cover general business and employee expenses, track purchases and set limits, facilitate gig economy on-demand disbursements, or execute gift card donations. Commercial prepaid card products have the following features:
Commercial prepaid cards require funding through a bank account. When additional funds are needed, a transfer is initiated to the account holder's financial account in Highnote, making the funds ready for use.
This guide provides an overview of creating and setting up a commercial prepaid card product in the test environment.
Use the following mutation to create a commercial prepaid card product. Use COMMERCIAL_PREPAID
as the vertical
input variable:
xxxxxxxxxx
mutation CreateCardProduct($input: CreateCardProductInput!) {
createCardProduct(input: $input) {
__typename
... on CardProduct {
id
name
usage
}
... on UserError {
errors {
errorPath
code
description
}
}
}
}
Commercial prepaid cards are used by US business account holders. Use the following mutation to create a US business account holder:
xxxxxxxxxx
mutation CreateUSBusinessAccountHolder(
$input: CreateUSBusinessAccountHolderInput!
) {
createUSBusinessAccountHolder(input: $input) {
__typename
... on USBusinessAccountHolder {
externalId
id
primaryAuthorizedPerson {
id
email
createdAt
updatedAt
}
businessProfile {
id
createdAt
updatedAt
ultimateBeneficialOwners {
id
email
createdAt
updatedAt
}
}
}
}
}
After creating an account holder, you can open an application to onboard them to your card product. Opening an application triggers identity verification processes. You can participate in the application decisioning process using Collaborative Application Decisioning.
In some cases, additional documents may be required to approve an application. For more information on collecting additional documents, see Request Documents for Application Review.
Use the following mutation to open an application for an account holder:
xxxxxxxxxx
mutation createAccountHolderCardProductApplication(
$input: CreateAccountHolderCardProductApplicationInput!
) {
createAccountHolderCardProductApplication(input: $input) {
__typename
... on AccountHolderCardProductApplication {
id
applicationState {
status
}
updatedAt
createdAt
}
... on UserError {
errors {
errorPath
code
description
}
}
}
}
Financial accounts hold the balance for payment cards. To create a new financial account, pass the id
of a verified application.
Financial accounts have an externalId
variable field that allows you to tie the Financial account to an entity in your system. If you do not pass in an externalId
, Highnote will generate one.
Use the following mutation to issue a financial account for an application:
xxxxxxxxxx
mutation IssueFinancialAccountForApplication(
$input: IssueFinancialAccountForApplicationInput!
) {
issueFinancialAccountForApplication(input: $input) {
... on FinancialAccount {
id
externalId
name
createdAt
updatedAt
application {
id
createdAt
}
cardProduct {
id
vertical
}
features {
__typename
enabled
createdAt
updatedAt
}
directDepositDetails {
id
restrictedDetails {
__typename
... on DirectDepositDetailRestrictedDetails {
number
routingNumber
bank {
name
}
}
}
}
owner {
__typename
... on USPersonAccountHolder {
id
}
}
}
}
}
Once you have created a financial account, you can issue a payment card. By default, all payment cards start as virtual cards. After you issue a virtual card, you can create a physical card order if needed.
Use the following mutation to issue a virtual card:
xxxxxxxxxx
mutation IssuePaymentCardForFinancialAccount(
$input: IssuePaymentCardForFinancialAccountInput!
) {
issuePaymentCardForFinancialAccount(input: $input) {
... on PaymentCard {
id
bin
last4
expirationDate
network
status
financialAccounts {
id
name
}
restrictedDetails {
... on PaymentCardRestrictedDetails {
cvv
number
}
... on AccessDeniedError {
message
}
}
}
... on UserError {
errors {
code
errorPath
description
}
}
}
}
mutation IssuePaymentCardForFinancialAccount(
$input: IssuePaymentCardForFinancialAccountInput!
) {
issuePaymentCardForFinancialAccount(input: $input) {
... on PaymentCard {
id
bin
last4
expirationDate
network
status
financialAccounts {
id
name
}
restrictedDetails {
... on PaymentCardRestrictedDetails {
cvv
number
}
... on AccessDeniedError {
message
}
}
}
... on UserError {
errors {
code
errorPath
description
}
}
}
}
By default, all payment cards start as virtual cards. Highnote also supports issuing personalized payment cards to account holders. For more information on issuing physical cards, see Print Physical Cards.
Highnote supports issuing tokenized cards. Account holders can add tokenized cards to digital wallets like Apple and Google Pay. For more information, see Add Cards to Digital Wallets.
Warning: The Highnote test environment lets you explore the platform features and functionality. It is intended for experimenting, building integrations, and training your team.
To ensure the security of your real-world data, please do not use production data in the test environment. Production data includes sensitive information like customer details, financial data, or personally identifiable information (PII).
Use only dummy or test data explicitly created for testing purposes in the test environment.
In the live environment, non-originated ACH transfers are initiated by account holders. In the test environment, you can simulate a non-originated ACH transfer to fund a financial account using the following mutation:
xxxxxxxxxx
mutation simulateNonOriginatedAchTransfer(
$input: SimulateNonOriginatedAchTransferInput!
) {
simulateNonOriginatedAchTransfer(input: $input) {
__typename
... on NonOriginatedAchTransfer {
id
amount {
currencyCode
value
}
createdAt
updatedAt
ledgers {
id
name
normalBalance
asOf
debitBalance {
value
currencyCode
}
creditBalance {
value
currencyCode
}
}
type
purpose
sign
traceNumber
status
statusFailureReason
settlementDate
processedAt
failedAt
returnSentToBankAt
}
}
}
Prepaid and payroll card have the DIRECT_DEPOSIT
feature enabled by default. Financial accounts with the DIRECT_DEPOSIT
feature have an associated account and routing number that can be used to transfer funds into the account from outside Highnote.
To display the account and routing number in your website or application, you can fetch them from the API by generating a Client Token and using that token to view the restricted details. The following graphic shows an example of what fetching an account and routing number looks like:
Use the following query to view direct deposit information:
xxxxxxxxxx
query ViewDirectDepositDetails($id: ID!) {
node(id: $id) {
... on FinancialAccount {
directDepositDetails {
id
restrictedDetails {
__typename
... on DirectDepositDetailRestrictedDetails {
number
routingNumber
}
}
}
}
}
}
Warning: Highnote recommends using the Card Viewer SDK to securely display payment card data and and reduce PCI non-compliance.
There are two methods for displaying payment card data on your website or application:
To fetch payment card data from the API, use the following query:
xxxxxxxxxx
query FindPaymentCard($id: ID!){
node(id: $id) {
...on PaymentCard {
bin
last4
expirationDate
restrictedDetails {
...on PaymentCardRestrictedDetails {
cvv
number
}
}
}
}
}
After configuring your card product, we recommend simulating transactions. Simulating transactions is useful for testing your card program's configuration and settings.
For more information on simulating transactions, see Simulate Transactions.
After configuring your card product and simulating transactions, you can use the following features to further expand your integration: