Consumer Prepaid

Fleet

Product Verticals

An AP Automation Card Product allows you to issue single-use debit cards funded from a Financial Account owned by a business. These are Virtual Payment Cards available on your app or website issued for specific transactions with Authorizations controlled by spend rules.

![apAutomation.gif](https://media.graphassets.com/ZnQuOp5hQqewJ9FTNr79)

Overview

In the Test Environment, you can create an Invoice Automation Card Product from the Highnote Dashboard or with the `CreateCardProduct` mutation in the [Highnote GraphQL API](/docs/basics/graphql-api/using-the-highnote-graphql-api). 

~~~graphql
mutation CreateCardProduct($input: CreateCardProductInput!) {
  createCardProduct(input: $input) {
    __typename
    ... on CardProduct {
      id
      name
      usage
    }
    ... on UserError {
      errors {
        path
        code
        description
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "createCardProduct": {
        "__typename": "CardProduct",
        "id": "Y2FyZHBy",
        "name": "Invoice Automation",
        "usage": "SINGLE_USE"
    }
  },
  "extensions": {
    "requestId": "b85fc1ec-e770-9d06-922f-16b7486a690e"
  }
}
~~~

CreateCardProduct - Invoice Automation

Create an AP Automation Card Product

Once you've created your Commercial Card Product, you create a Business Account Holder. Account Holders may be issued Payment Cards from multiple Card Products.

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
          }
        }
      }
   }
}

~~~json
{
  "data": {
    "createUSBusinessAccountHolder": {
      "__typename": "USBusinessAccountHolder",
      "externalId": "bluejay",
      "id": "og_ah02e174203daf3f4bab86fd6c6895e50141",
      "primaryAuthorizedPerson": {
        "id": "ps_ap017a1ab7278af44e7eb9881a845aefd0d5",
        "email": "foo@example.com",
        "createdAt": "2023-01-26T15:14:21.891Z",
        "updatedAt": "2023-01-26T15:14:22.070Z"
      },
      "businessProfile": {
        "id": "og_ah02e174203daf3f4bab86fd6c6895e50141",
        "createdAt": "2023-01-26T15:14:21.891Z",
        "updatedAt": "2023-01-26T15:14:22.070Z",
        "ultimateBeneficialOwners": [
          {
            "id": "ps_ap01ce29588db6e345ca95c4f037dc9bc9b1",
            "email": "james@example.com",
            "createdAt": "2023-01-26T15:14:21.891Z",
            "updatedAt": "2023-01-26T15:14:22.070Z"
          }
        ]
      }
    }
  },
  "extensions": {
    "requestId": "7b1488d4-c9fd-9084-8eee-6f3e21b12wez"
  }
}
~~~

CreateUSBusinessAccountHolder - Corporate Expense

Create a Business

Once you have created an Account Holder, you can open an Application to onboard them to your Card Product.

Opening an Application triggers the identity verification checks (KYC) necessary for your Card Product. These checks must pass in order to onboard the Account Holder. To create the Application you will need the `cardProductId` and `primaryAuthorizedPersonId`.

When the Application is opened, it will be in a `PENDING` state. This means the Application is being reviewed and the appropriate KYC checks are running against the Account Holder. You can only have one Application open at a time for a given Card Product and Account Holder.

### Capturing Consent
Before an Application is submitted, the required terms and conditions and relevant disclosures for the Card Product (e.g. the Cardholder Agreement) must be presented and agreed to by the Account Holder. An Account Holder’s consent must be captured before opening an Application and include *who* is consenting, `primaryAuthorizedPerson`, *what* they are consenting to, `cardProductID`, and when they consented, `consentTimestamp`.

~~~graphql
mutation createAccountHolderCardProductApplication(
  $input: CreateAccountHolderCardProductApplicationInput!
) {
  createAccountHolderCardProductApplication(input: $input) {
    __typename
    ... on AccountHolderCardProductApplication {
      id
      applicationState {
        status
      }
      updatedAt
      createdAt
    }
    ... on UserError {
      errors {
        path
        code
        description
      }
    }
  }
}

~~~

~~~json
{
  "data": {
    "createAccountHolderCardProductApplication": {
      "__typename": "AccountHolderCardProductApplication",
      "id": "APPLICATION_ID",
      "applicationState": { "status": "PENDING" },
      "createdAt": "2021-07-07T23:22:30.475Z",
      "updatedAt": "2021-07-07T23:22:30.475Z"
    }
  },
  "extensions": {
    "requestId": "REQUEST_ID"
  }
}
~~~

createAccountHolderCardProductApplication

For compliance and fraud, we currently prevent opening an Application from the Dashboard in all Live Environments. 

Open an Application

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

~~~graphql
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
        }
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "issueFinancialAccountForApplication": {
      "id": "FINANCIAL_ACCOUNT_ID",
      "externalId": "ABC123456",
      "name": "John Doe - Account",
      "createdAt": "2021-12-28T18:20:49.932Z",
      "updatedAt": "2021-12-28T18:20:49.960Z",
      "application": {
        "id": "APPLICATION_ID",
        "createdAt": "2021-12-20T17:59:33.570Z"
      },
      "cardProduct": {
        "id": "CARD_PRODUCT_ID",
        "vertical": "GENERAL_PURPOSE_RELOADABLE"
      },
      "features": [
        {
          "__typename": "DirectDepositFinancialAccountFeature",
          "enabled": true,
          "createdAt": "2021-12-28T18:20:49.933Z",
          "updatedAt": "2021-12-28T18:20:49.933Z"
        },
        {
          "__typename": "DebitPaymentCardFinancialAccountFeature",
          "enabled": true,
          "createdAt": "2021-12-28T18:20:49.933Z",
          "updatedAt": "2021-12-28T18:20:49.933Z"
        }
      ],
      "directDepositDetails": {
        "id": "FINANCIAL_ACCOUNT_ID",
        "restrictedDetails": {
          "__typename": "AccessDeniedError"
        }
      },
      "owner": {
        "__typename": "USPersonAccountHolder",
        "id": "ACCOUNT_HOLDER_ID"
      }
    }
  }
}
~~~

Issue a Financial Account

Once you have created and funded a Financial Account, you can issue a Payment Card. All Payment Cards start as a virtual card, and can later be ordered as a physical card. 

~~~graphql
mutation IssuePaymentCardForFinancialAccount($input: IssuePaymentCardForFinancialAccountInput!) {
  issuePaymentCardForFinancialAccount(input: $input) {
    ... on PaymentCard {
      id
      bin
      last4
      expirationDate
      network
      status
      
      financialAccounts {
        id
      }
      
      restrictedDetails {
        ... on PaymentCardRestrictedDetails {
          cvv
          number
        }
        ... on AccessDeniedError {
          message
        }
      }
    }
    ... on UserError {
      errors {
        path
        code
        description
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "issuePaymentCardForFinancialAccount": {
      "id": "PAYMENT_CARD_ID",
      "bin": "510515",
      "last4": "7162",
      "expirationDate": "2027-01-01T23:59:59Z",
      "network": "MASTERCARD",
      "status": "ACTIVE",
      "financialAccounts": [
        {
          "id": "FINANCIAL_ACCOUNT_ID"
        }
      ],
      "restrictedDetails": {
        "message": "Access is denied"
      }
    }
  }
}
~~~

Issue a Payment Card with a Financial Account

Issue a Payment Card

To display the primary account number (PAN) and CVV to users, you can fetch them from the API by adding `number` and `cvv` to the selection set

~~~graphql
query FindPaymentCard($id: ID!){
  node(id: $id) {
    ...on PaymentCard {
      bin
      last4
      expirationDate
      restrictedDetails {
        ...on PaymentCardRestrictedDetails {
          cvv
          number
         }
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "node": {
      "bin": "",
      "last4": "",
      "expirationDate": "",
      "restrictedDetails": {
        "cvv": "",
        "number": ""
      }
    }
  }
}
~~~

Node Query for PCI Data

Selecting the `number` or `cvv` fields requires that you are PCI compliant.

Highnote recommends using the [Card Viewer SDK](/docs/basics/clientside-and-sdks/card-viewer-sdk) to securely display payment card data and and reduce PCI burden. 

Display Payment Card Data

Once you've completed the basics of setting up your card product, you can expand and test your integration further:

- [Simulate Transactions in the Test Environment](/docs/guides/transactions/simulate-transactions) to ensure your integration works
- Create [Spend Rules](/docs/guides/auth-controls/spend-rules) to control the way your cards can be used
- Setup [Notifications](/docs/basics/events-and-notifications/notifications) to automate your integration

AP Automation