Streamline Virtual Card Issuance with These 5 Steps

▶ Watch the 60-second version on YouTube

Harnessing Virtual Cards for Your Fintech Product

Virtual cards have transformed how businesses manage spending and streamline payments. The ability to issue virtual cards on-demand allows for enhanced control over transactions, making them a go-to solution for many fintech applications. Whether you're building a payment platform or integrating spending controls into a corporate expense tool, mastering virtual card issuance is crucial.

Let’s dive into five steps to efficiently issue virtual cards using Stripe Issuing and Marqeta APIs. We'll create a straightforward process that can be integrated into your existing fintech product.

Step 1: Setting Up Your API Keys

First things first, ensure you have your API keys ready. For both Stripe and Marqeta, you'll need access to their developer dashboards to generate the necessary credentials. Keep these credentials confidential, as they'll enable you to authenticate and make requests to their services.

Step 2: Create Your Virtual Card Program

Before issuing any virtual cards, you need a card program. This involves defining the parameters for card issuance, including spending limits, transaction types allowed, and any other controls you wish to impose.

Here’s how to create a card program using Stripe Issuing:

import stripe

# Set your secret key
stripe.api_key = 'your_stripe_secret_key'

# Create a card program
program = stripe.Issuing.Card.create(
    cardholder='cardholder_id',
    currency='usd',
    spending_controls={
        'spending_limits': [
            {
                'amount': 10000,  # Set a limit of $100
                'interval': 'monthly',
            },
        ],
        'allowed_categories': ['food', 'travel'],
    },
)

print("Card Program Created: ", program)

Step 3: Issue the Virtual Card

Once you've set up your card program, issuing a virtual card is straightforward. For Stripe, you can leverage the card program created in the previous step. Here's how you can issue a new virtual card:

# Issue a virtual card
virtual_card = stripe.Issuing.Card.create(
    cardholder='cardholder_id',
    currency='usd',
    type='virtual',  # Specify virtual card type
    program='program_id',  # Use the program created earlier
)

print("Virtual Card Issued: ", virtual_card)

Step 4: Tokenize the Card for Transactions

For security and compliance, tokenization is essential. Use the Visa Token Service or similar services to tokenize card details and facilitate secure transactions without exposing sensitive data. Here’s an example using Visa Token Service:

import requests

# Replace with your Visa Token Service URL and access token
url = 'https://api.visa.com/v1/tokens'
headers = {
    'Authorization': 'Bearer your_access_token',
    'Content-Type': 'application/json'
}

data = {
    "accountNumber": virtual_card['last4'],  # Use last 4 digits
    "expiryDate": "12/25",  # Example expiration date
}

response = requests.post(url, json=data, headers=headers)
token_response = response.json()

print("Tokenized Card Details: ", token_response)

Step 5: Implement Spending Controls and Monitoring

After issuing the card and tokenizing it, the final step is to implement spending controls and real-time monitoring. Both Stripe and Marqeta provide robust tools to manage how and where cards are used. For example, you can track transaction history and enforce limits.

Utilizing webhooks to monitor transaction events is a great way to keep your application in sync with card activity. For instance, you can listen for transaction events and take action based on the data received:

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    event = request.json
    if event['type'] == 'issuing.card.transaction.approved':
        # Process the approved transaction
        print("Transaction Approved: ", event['data'])
    return "", 200

if __name__ == '__main__':
    app.run(port=5000)

Non-Obvious Gotcha

One common oversight when working with virtual cards is the handling of expiration dates. Many developers assume that virtual cards are long-lived, but they often come with expiration dates just like physical cards. Make sure to implement logic to handle expired cards gracefully. This includes notifying users when their cards are about to expire and providing a seamless way to issue new cards without interruption.

Additionally, be aware of the limits imposed by both Stripe and Marqeta regarding the number of virtual cards that can be issued per program or cardholder. Exceeding these limits can lead to failed requests that can disrupt your user experience.

Final Thoughts

Integrating virtual card issuance into your fintech product can enhance user experience and provide robust spending controls. By following these steps and keeping an eye on the gotchas, you can create a streamlined process that not only meets your business needs but also scales effectively as your user base grows.