A card issuing API lets your application create, issue and manage payment cards with code instead of paperwork. One request can create a virtual card that’s ready to use seconds later. Another can freeze it, change its spending limit or close it.
This guide is for developers and technical decision-makers who need to understand how that works in practice. We cover what happens between your API call and a working card, which card types you can issue, how access to Visa and Mastercard actually works, who is responsible for security and compliance, and what to test before you commit to a provider.
We also look at the trade-offs and at one new use case, cards issued to AI agents, that shows how far the technology has moved. It’s not a vendor ranking. If you’re comparing named providers on commercial terms, that’s a separate exercise. Here, the focus is on the integration itself. For context on how card issuing fits into a broader product, see our overview of cards-as-a-service.
What Is a Card Issuing API?
If you’ve ever wondered what is an API for credit cards and other payment cards, the short answer is this: it’s an interface that connects your application to regulated card infrastructure.
Traditionally, issuing cards meant working directly with a bank. You’d sign a long contract, wait months for a program to be set up, and then rely on manual, bank-led processes for every change. Ordering cards, adjusting limits or blocking a lost card often meant emails, forms and back-office teams.
A card issuing API replaces that with programmable calls. Your application talks to a provider that already holds the network connections, the issuing licence or sponsor relationship, and the processing infrastructure. You send requests. The provider handles the regulated plumbing.
The API covers the full card lifecycle:
- Creation: generating a card linked to a customer and an account
- Activation: enabling the card for use, immediately for virtual cards or after delivery for physical ones
- Transaction monitoring: receiving authorization requests and transaction events as they happen
- Suspension and closure: freezing, unfreezing or terminating a card instantly
Each of these is an API call or an event, not a manual back-office task. That’s what makes card programs something a product team can build and change quickly.
How Do Card Issuing APIs Work?
Here’s how card issuing APIs work, step by step, from a single request to a card in use.
Your application sends an issuance request. It specifies the card type (virtual or physical), the network, the currency and the customer or account the card belongs to. A simplified request might look like this. It’s illustrative rather than any specific provider’s format:
json
{
"account_id": "acc_8f2d",
"cardholder_id": "ch_41b7",
"type": "virtual",
"currency": "EUR",
"spending_limit": { "amount": 50000, "interval": "monthly" }
}
The provider creates the card and applies program-level rules automatically. These are set when the program is configured and include which BIN range the card number comes from, which transaction types and merchant categories are allowed, default spending limits and the expiry period. Your request only needs to cover what’s specific to this card.
Then the two card types diverge. A virtual card is usually active immediately. The API can return the card details, or a secure token for displaying them, within seconds. A physical card triggers fulfillment: printing, personalization and mailing. It typically needs activation once the cardholder receives it.
From there, real-time webhooks notify your application as events happen: authorizations, settled transactions, declines, refunds and disputes. Your system can update balances, notify users or flag unusual activity without polling.
Some programs also use just-in-time (JIT) funding. Instead of preloading a card, funds are moved only when an authorization request arrives and your system approves it. That keeps money off cards until it’s needed. We cover JIT in more detail in the FAQs.
For the product side of instant cards, see our guide to tarjetas virtuales.
¿Estás listo para actualizar tu infraestructura de pagos?
Deja de lidiar con flujos de pago fragmentados. Accede a IBAN específicos, SEPA Instant e integraciones API sin complicaciones, todo ello desde una única plataforma unificada.
Types of Cards You Can Issue via API
Most providers support several card types through the same API, often using the same endpoints with different parameters.
- Physical debit cards are linked to an account and work for in-store payments, contactless and ATM withdrawals. A debit card issuing API handles their creation, fulfillment and activation, along with PIN management.
- Tarjetas de débito virtuales have no physical form. They exist only as card details, or as tokens added to Apple Pay or Google Pay. They’re ideal for online purchases, subscriptions and instant access while a physical card is in the post. Virtual card APIs are usually the fastest place to start, because nothing has to be manufactured or shipped.
- Prepaid cards are loaded with a set amount and don’t need a full current account behind them. They’re common for gift cards, expense allowances, benefits programs and payouts to people who don’t share their bank details.
- Tarjetas de empresa are issued to employees and controlled centrally, with spending limits by person, team, merchant category or time period. Expense platforms rely heavily on these.
- Virtual credit cards let businesses generate a card number for a single supplier, booking or purchase. That adds a security layer for online payments, because a compromised number can be closed without affecting anything else.
A credit card issuing API involves extending credit, not just moving funds a customer already has. That brings credit risk, underwriting, collections and extra regulatory requirements. Debit and prepaid programs are usually much quicker to launch for that reason. For more on how virtual debit cards work, see our explainer on the tarjeta de débito virtual.
Card Issuing APIs and the Visa/Mastercard Network
Developers often ask whether they can just use a Visa card issuing API directly. The answer surprises some teams.
Visa and Mastercard both run developer platforms with real, well-documented APIs. But the issuer-facing capabilities are largely restricted to licensed issuers, banks and their processing partners. A typical business can’t sign up and start issuing cards on the networks the way it might sign up for a payment gateway.
That’s because issuing a card on a network requires a principal membership or sponsorship, a BIN range, a licensed issuer accountable for the program, a processor that can handle authorization traffic in milliseconds, and compliance with each network’s rules. Building that directly takes years and significant capital.
In practice, nearly every business accesses Visa and Mastercard issuance through a licensed processor or BaaS provider that has already built the network integration. Their payment card issuing API sits on top of that relationship. You integrate with the provider, and the provider handles the network.
This is the realistic path for almost every company evaluating card issuing. The question isn’t whether to build on Visa or Mastercard directly, but which licensed intermediary to build on. Our overview of Proveedores de «banca como servicio» explains how those intermediaries are structured.
Benefits of Card Issuing APIs
The card issuing API benefits are clearest when you compare them with the traditional bank-led route.
- Cards can be issued instantly. A virtual card can be created and used within seconds, while physical card fulfillment is triggered automatically from the same request. There’s no separate ordering process.
- Workflows can be automated. Creation, activation, limit changes, freezing and closure become code paths in your product. A user who reports a lost card can freeze it in your app, and a new virtual card can be issued straight away.
- Webhooks provide real-time visibility. Transaction events arrive as they happen, so you can show users live balances, send instant purchase notifications or trigger fraud checks.
- Spending controls are flexible. Limits and restrictions can be set by amount, merchant category, country, channel or time period, and changed at any moment through the API.
- Reporting improves. Transaction-level data flows into your systems, giving finance teams immediate visibility instead of waiting for monthly statements.
- Launches get faster. Because the provider already has the network connections, licensing and processing in place, a card program can go live in weeks rather than the many months a traditional bank program can take.
- There’s also a commercial upside. Branded cards embedded in an existing platform can generate interchange revenue and make the product harder to leave. For a wider view of API-led providers, see our list of the Las mejores empresas de API fintech.
Security and Compliance Responsibilities
This is where card issuing is often marketed loosely, so it’s worth being precise.
Card issuing APIs usually include tools that make day-to-day compliance easier. Typical examples are built-in KYC checks for cardholders, PCI DSS-compliant handling of card data, tokenized card display so your servers never see full card numbers, and encryption throughout. These tools take a lot of work off your team.
But using them doesn’t make compliance someone else’s problem. The licensed issuer behind the program holds the issuing licence and answers to its regulator for the program. Your business still carries responsibilities of its own. Those include how you onboard and monitor your customers, how you market the card, how you handle personal data, and any obligations your provider contractually passes on to you. Regulators and networks expect both parties to do their part.
Some baseline requirements apply whatever provider you choose:
- Cumplimiento de la norma PCI DSS for any system that stores, processes or transmits card data. Using tokenized display can shrink that scope significantly.
- Cifrado for data in transit and at rest.
- Access controls, including two-factor authentication for anyone who can issue cards, change limits or view sensitive data.
Local rules apply too. In the EU, GDPR governs cardholder data, and payment regulation shapes how cards can be issued and marketed. Elsewhere, jurisdiction-specific financial regulation applies to the business operating the program. Our approach to cumplimiento integrado is designed to carry as much of this as the regulated side can.
Challenges of Card Issuing APIs
Card issuing APIs make launching a card program far easier, but they come with trade-offs worth planning for.
- Vendor lock-in is real. Card numbers, BIN ranges, tokens and cardholder records are tied to your provider. Switching later can mean reissuing every card, which is disruptive for users and expensive for you. Choose your card issuing API provider as if you’ll stay for years.
- Relying on third-party infrastructure raises data security questions. Your customers’ card data and transactions pass through another company’s systems. You need confidence in its security practices, audits and incident response.
- Customization has limits. Providers support a defined set of card types, controls and features. If your program needs something unusual, such as a particular authorization rule or card design, you may have to wait for the provider’s roadmap or work around it.
- Setup still takes expertise. Even with good documentation, you’ll need engineers who understand authorization flows, webhooks, idempotency, reconciliation and secure handling of card data.
- Latency and downtime affect live transactions. If you use JIT funding or real-time authorization decisions, your system and the provider’s must both respond within strict time limits. An outage on either side means declined payments at the till.
None of this is a reason to avoid card issuing APIs. It’s a reason to evaluate providers carefully.
How to Evaluate a Card Issuing API Provider
When you compare card issuing API providers from a technical angle, a few criteria tell you more than any feature list.
- Start with the documentation and SDKs. Are endpoints, error codes and edge cases clearly documented? Are there maintained SDKs for your stack? Poor documentation turns a two-week integration into a two-month one.
- Check for a free sandbox. You should be able to create cards, simulate authorizations, trigger declines and fire webhooks before signing anything. Among virtual card issuing API providers, sandbox quality varies more than you’d expect.
- Test the webhooks. Look at event coverage, delivery guarantees, retry behaviour, signature verification and ordering. Missed or duplicated events cause reconciliation problems that are hard to fix later.
- Clarify what’s included. Which features work out of the box, and which need custom development? Card controls, 3-D Secure, wallet provisioning, PIN management and dispute handling are common gaps.
- Ask about support. Who do you contact when authorizations start failing on a Friday night, and how fast do they respond?
- Finally, insist on transparent pricing, including per-card, per-transaction, fulfillment and monthly fees.
For a business-side comparison of named providers, a dedicated card issuing platforms review is the better resource. Card programs also sit alongside acceptance, which we cover in our piece on seamless card acquiring.
What’s Next: Card Issuing APIs for AI Agents
One new use case shows how flexible card issuing APIs have become: cards for AI agents.
When a user asks an AI agent to book a flight or buy a product, the agent needs a way to pay without being handed the user’s main card. Some newer platforms now issue ephemeral, single-use virtual cards for this. Each card is tied to one authorized purchase, limited to a specific amount and merchant, and closed automatically afterwards. Some last only minutes.
These are often paired with passkey-based consent, so the user confirms each purchase with a biometric check. The card networks are working on related approaches, with Visa and Mastercard both announcing programs for agent-initiated payments.
This is still early and far from mainstream. But it’s a good example of what programmable cards make possible beyond traditional consumer and corporate programs.
How ConnectPay Approaches Card Issuing
ConnectPay offers white-label card issuing, virtual and physical, as part of our EMI-licensed, API-first platform. Businesses can issue cards under their own brand without building network integrations, managing card production or setting up compliance infrastructure from scratch.
That fits the pattern described earlier. Most businesses reach Visa and Mastercard through a licensed intermediary, and for European card programs, we’re that intermediary. We hold the EMI licence, run KYC and AML checks, and connect the cards to the same platform as multi-currency IBAN accounts and SEPA and SWIFT payments.
For a platform, that means cards can be linked to real accounts from day one. A marketplace could issue virtual cards to sellers for business expenses. An expense tool could give employees physical cards with limits set in its own interface. A fintech could launch a branded debit card alongside its accounts.
Because cards, accounts and compliance sit with one licensed provider, there’s one integration to maintain and one party to call when something goes wrong. You can see the options on our tarjetas de marca blanca página.
Build the Card Program, Not the Infrastructure Underneath It
The real value of a card issuing API is focus. Network connections, licensing, card production and transaction processing are hard, regulated and largely invisible to your users. A good provider handles them, so your team can put its effort into the parts that make your product different: the card program logic, the controls your users need, and the experience in your app.
That only works if the integration itself is solid. So before you compare feature lists, read the documentation, open the sandbox and build a small prototype. Issue a card, run a few test transactions, trigger a decline and handle a webhook. A day spent testing will tell you more than weeks of sales calls, and it will save far more time during integration.
If you’re planning a card program for European customers, talk to ConnectPay about what you’d like to build.








