Stripe Issuing vs Marqeta vs Lithic Card Issuing API (2026)

Why Card Issuing APIs Are a Real Buy Decision Now

Card issuing used to be infrastructure only neobanks cared about. In 2026, almost every B2B SaaS with reimbursement, every AI agent platform spending on behalf of users, and every marketplace paying suppliers ends up evaluating one of these three: Stripe Issuing, Marqeta, or Lithic. The decision has consequences for unit economics, time-to-market, and the kind of program you can run two years from now when you actually have scale.

This guide compares all three on the dimensions that determine the outcome: program speed, controls API, interchange share, and what happens when you push past the starter tier.

TL;DR

• Stripe Issuing is the fastest path from zero to live cards if you are already on Stripe. It is also the most opinionated — you get a managed program, decent controls, and no real interchange revenue share until you negotiate a custom contract.
• Marqeta is the enterprise standard. Powers most large fintechs you have heard of (DoorDash, Klarna, Square Cash). Highest flexibility, biggest sales motion, longest implementation. Real interchange share is on the table.
• Lithic sits in between: developer-experience close to Stripe, program flexibility close to Marqeta, and a clear interchange revenue model from day one. Built by the team behind Privacy.com.

If you are a startup wiring up cards in a sprint, start with Stripe Issuing. If you have a real card program with margin pressure, Lithic is the surprising default. Marqeta makes sense once you cross seven figures in monthly volume or need exotic program types (debit, prepaid, push-to-card).

Key Takeaways

• Time-to-first-card in 2026: Stripe Issuing ~1 day, Lithic 3–7 days, Marqeta 3–6 months for a real production program.
• Interchange revenue share: Lithic and Marqeta both pass through; Stripe Issuing only does so on negotiated custom plans.
• BIN sponsorship: Stripe sponsors directly (Celtic Bank in the US), Marqeta supports your choice of bank partners, Lithic uses Sutton Bank with a path to bring your own BIN.
• Controls API: Marqeta has the deepest controls (real-time JIT funding, MCC velocity rules), Lithic exposes the same primitives via REST, Stripe leans on declarative card-level limits.
• Card networks: All three support Visa and Mastercard; only Marqeta has the relationships for niche networks like Discover.

Decision Table

Priority	Pick	Why
Ship cards in a week	Stripe Issuing	Bundled with existing Stripe stack
Capture interchange margin	Lithic	Transparent share, low minimums
Run a regulated debit/prepaid program	Marqeta	Bank-network optionality
AI agent spending controls	Lithic or Stripe	Real-time auth webhooks
Global multi-region issuance	Marqeta	UK, EU, AU programs at parity
White-label corporate cards	Lithic	Cleanest API, fast embossing

Stripe Issuing

Stripe Issuing is the path of least resistance. If your stack is already on Stripe, you can issue a virtual card with one API call and have a customer using it in production the same afternoon. Cardholders, authorizations, transactions, and disputes all live in the same dashboard you already use for PaymentIntents.

const card = await stripe.issuing.cards.create({
  cardholder: "ich_123",
  currency: "usd",
  type: "virtual",
  spending_controls: {
    spending_limits: [{ amount: 50000, interval: "monthly" }],
    allowed_categories: ["computer_software_stores", "computers_peripherals_and_software"],
  },
});

The spending controls API is genuinely good. You get card-level limits, MCC allow/block lists, and a live authorization webhook (issuing_authorization.request) for just-in-time decisions. That webhook is the same primitive AI agent companies are using to gate spending on tool calls.

What you give up:

• Interchange revenue is bundled into Stripe's pricing. Default plans are net-cost — you pay $0.10 per authorization plus card production fees, and Stripe keeps interchange. To unlock revenue share you have to negotiate, and it usually means doing $1M+/month in volume.
• Bank flexibility is zero. Your BIN sits with Stripe's partner banks; you cannot bring your own.
• Program shape is fixed: charge cards funded from your Stripe balance, with limited support for prepaid or true debit.

Stripe Issuing is best for SaaS adjacencies — expense cards inside your product, vendor virtual cards inside an AP automation tool, AI agent spending control. It is the wrong tool for fintech-as-a-product where the cards are the business.

Marqeta

Marqeta is the platform that powered the first generation of card-led fintechs. In 2026 it is still the platform you choose when you need full programmatic control over auth flows, card production, and bank-rail behavior. JIT funding — where your servers approve every authorization in real time and only fund the transaction at swipe — is something Marqeta perfected and the others copied.

The product surface is huge: managed credit, debit, prepaid; commercial and consumer; Visa, Mastercard, Discover. Their API is a REST service organized around cards, users, gpa_orders, and transactions. Webhooks drive the JIT model.

The hard part is everything that is not the API. You will have a sales conversation, a compliance review, a bank intro (typically Sutton, Pathward, or Stride), and a 3–6 month implementation. Pricing is custom and includes platform fees, per-card fees, and per-transaction fees, with interchange typically passed through. For a serious program, that economics math wins.

Pick Marqeta when:

• You are building a regulated debit or prepaid program.
• You need to operate in the US, UK, EU, and AU on a single platform.
• Your volume is high enough that interchange optimization is a real line item.

Skip Marqeta when:

• You need cards live this quarter.
• You will never exceed a few thousand cards.
• You do not want the operational lift of program management.

Lithic

Lithic is the most underrated option. The team built Privacy.com (the consumer virtual card service), then opened the underlying platform for B2B use. The result is a developer experience close to Stripe with a program model close to Marqeta — and meaningful interchange share at any volume.

const card = await lithic.cards.create({
  type: "VIRTUAL",
  spend_limit: 50000,
  spend_limit_duration: "MONTHLY",
  state: "OPEN",
});

The Lithic API uses the same JIT funding pattern as Marqeta but exposes it more cleanly. You implement an auth_stream webhook handler, your service decides approve or decline with reason code, and Lithic enforces it on the network. That makes Lithic the easiest of the three for AI agent and corporate-card use cases where every transaction is policy-checked.

What is good:

• Interchange revenue share is transparent and starts at low volume.
• Program types include charge, prepaid, and debit through a sponsor bank.
• Sandbox and docs are at Stripe quality.

What is mid:

• Geographies are mostly US and Canada in 2026 — EU and UK are on the roadmap but trail Marqeta.
• Card production options (embossing, packaging, branded carriers) are fewer than Marqeta's print partners.

Who Should Choose What

• Pick Stripe Issuing if you are issuing cards as a feature of a SaaS product, you are already deep in Stripe, and you do not care about interchange margin.
• Pick Marqeta if cards are a core product, you have a real volume forecast, and you need program shape that smaller platforms cannot deliver.
• Pick Lithic if you want the developer experience of Stripe, the program flexibility of Marqeta, and interchange revenue from day one. This is the right answer for most card-issuing fintechs starting in 2026.

The Verdict

Stripe Issuing is the fast path. Marqeta is the heavy-duty platform. Lithic is the option more teams should be evaluating but skip because it has less marketing budget. Run pricing exercises with all three at 12-month projected volume; the interchange math will surprise you.

For related decisions, see our Stripe vs Paddle vs Lemon Squeezy payment API comparison and How to add Stripe payments to Next.js.