Print Physical Cards

Issue Cards

1. [A Highnote Account](https://dashboard.highnote.com/auth/signin?screen_hint=signup)
2. An [API Key](/docs/basics/graphql-api/using-the-highnote-graphql-api#authentication), the [API Explorer](/docs/explorer/default) or the [Dashboard](https://dashboard.highnote.com)
3. An [Account Holder with approved Application](/docs/guides/onboard/onboard-account)

Prerequisites to Issue Cards

Once the application is approved, you can issue a financial account with the `APPLICATION_ID` of an approved application. The financial account will hold the funds for cards issued against the account.

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

IssueFinancialAccountForApplication

Issue a Financial Account

With the financial account ready, you may issue a payment card. Cards are virtual by default and can later be upgraded to 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"
      }
    }
  }
}
~~~

IssuePaymentCardForFinancialAccount

Issue a Virtual Card

![payment-card-status-diagram.svg](https://media.graphassets.com/vI2THv1aRzWarmhR0uJF)
If you choose not to activate cards on creation, you can provide an experience for your account holders to activate their card from your app or site. Cards must be activated before you can set the required PIN.

~~~graphql
mutation ActivatePaymentCard($input: ActivatePaymentCardInput!) {
  activatePaymentCard(input: $input) {
    ...on PaymentCard {
      status
    }
    ...on UserError {
      errors {
        code
        path
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "status": "ACTIVE"
  }
}
~~~

Activate Payment Card

Activate a Card

Cards must have a PIN set after they are issued. This allows access to ATMs and/or receive cashback at checkout. The card must be `ACTIVE` in order to set the PIN.

For web-based integrations, Highnote recommends you set the PIN with the [Secure Inputs SDK](/docs/basics/clientside-and-sdks/secure-input-sdk).

For iOS and Android based integrations, you can securely set a PIN from the API with a [Client Token](/docs/basics/clientside-and-sdks/client-tokens).

~~~graphql
mutation SetPinForPaymentCard($input: SetPinForPaymentCardInput!) {
  setPinForPaymentCard(input: $input) {
    __typename
    ... on PaymentCard {
      id
    }
    ... on UserError {
      errors {
        path
        code
      }
    }
  }
}
~~~

~~~json
{
  "data": {
    "setPinForPaymentCard": {
      "__typename": "PaymentCard",
      "id": "PAYMENT_CARD_ID"
    }
  },
  "extensions": {
    "requestId": "REQUEST_ID"
  }
}
~~~

SetPinForPaymentCard

Set a PIN

With a virtual card issued, we can now work to [print it as a physical card](/docs/guides/cards/physical-card).

Next Guide: Print Physical Cards

Issue Your First Card

Test Your Integration

Using Ledgers

Controlling Authorizations with Spend Rules

Order Physical Cards

Managing Financial Accounts

GraphQL API

Search & Filters

Events & Notifications

Clientside & SDKs

Product Verticals

Dashboard

Control Authorizations

Transfer Funds

Handle Transactions

Manage Credit

Onboard Accounts

Compliance

Card Design

Using the Highnote API

Using GraphQL

API Error Handling

Search

API Status & Changes

Using the Dashboard

Team, Roles & Profile

Perform Searches

Manage your Integration

Client Tokens

Card Viewer SDK

Secure Inputs SDK

Notifications

Events

Events Reference

Virtual Cards

Physical Cards

Digital Wallets

API Reference

API Explorer

Basics

Onboard an Account

Request Documents for Application Review

Update an Account

Display Cards & Balances

Manage Cards

Add Cards to Digital Wallets

Print Cards in Bulk

Handle Account Suspension

Transaction Lifecycle

Simulate Transactions

Simulate Fleet Transactions

Build a Transaction Feed

Deliver Statements

Manage Disputes

Configure Spend Rules

Configure Velocity Controls

Collaborative Authorization

Add Funds to your Balance

Connect External Accounts

Add Funds to an Account

Move Funds Out of Highnote

Payroll Advance

Assign a Credit Line

Simulate Application Denial

Collaborative Underwriting 

Set & Update a Credit Limit

Schedule Repayments

Guides

Consumer Debit

Commercial Debit

Commercial Charge

Secured Commercial Charge

Fleet

AP Automation

Consumer Prepaid

Payroll

Marketing & Collateral

Cards in Marketing

Agreements & Disclosures

Concepts