All entries
Chapter VIII
Journal · 17 Nov 2026 · 10 min read

Stripe Issuing vs Lithic vs Marqeta: Auth Timeouts

Real-time card auth compared: Stripe 2s, Marqeta 3s, Lithic 6s, Adyen 2s. Response shapes, fallback defaults, stand-in advice and what skips your webhook.

If your authorisation endpoint takes 2.1 seconds to answer Stripe Issuing, a Dashboard setting you may never have opened decides whether the cardholder gets their coffee. Give Lithic the same 2.1 seconds and nothing goes wrong, because Lithic waits six seconds before it declines.

Every issuing platform that lets your server approve card transactions looks alike from a distance. Up close, the four big APIs disagree on deadlines, fallbacks and which transactions never ask you. The pages ranking for these queries are single-provider docs, so this guide puts Stripe Issuing, Lithic, Marqeta and Adyen side by side, from their API references and OpenAPI specs as of November 2026.

How Does Real-Time Authorisation Work in Card Issuing?

When a card you issued is used, the acquirer sends an ISO 8583 0100 request through the network to your issuer processor. The processor runs its own checks first, such as card status and any spend controls you configured. If those pass, it POSTs a JSON version of the request to your server and waits.

It is harder than an ordinary webhook because it is synchronous. The purchase waits on your HTTP response, so a slow query becomes a decline at the till. It is also only one of several paths a transaction can take.

The names differ. Stripe says real-time authorizations, Lithic says Auth Stream Access (ASA) and Adyen says relayed authorisation. Marqeta says Gateway JIT Funding, because you approve by agreeing to fund the transaction "just in time".

Stripe Issuing vs Lithic vs Marqeta vs Adyen: Timeouts in 2026

Stripe IssuingLithic ASAMarqeta Gateway JITAdyen relayed
Requestissuing_authorization.requestcard_authorization.approval_requestjit_funding, method: pgfs.authorizationbalancePlatform.authorisation.relayed
Deadline2 s6 s (Lithic asks for 3 s)3 s, lowerable via timeout_millis2000 ms (another doc page says 1500 ms)
Decline signal"approved": falseany result except APPROVED/CHALLENGEHTTP 402"status": "Refused"
Decline reasonsnone, metadata only10-value enum25-value decline_reason enumfree-text refusalReason
On timeoutDashboard timeout setting or Autopilotdeclinedecline, unless Commando Modeyour choice
On bad responsewebhook_error; Autopilot can decidedeclinedecline, unless Commando Modeyour choice, set separately
Partial approvalamount if is_amount_controllableapproved_amount if terminal capableamount if partial_approval_capablenot in response schema

The deadlines differ by a factor of three, but the fallback row matters more. Stripe and Adyen let you choose what a missed deadline means. Lithic and Marqeta decline by default and only change that through an enterprise arrangement or Marqeta's Commando Mode.

Stripe Issuing Real-Time Authorizations: The 2-Second Webhook

Stripe sends issuing_authorization.request to a synchronous endpoint configured in Issuing settings, separate from your normal webhook endpoints. You answer in the response body:

HTTP/1.1 200 OK
Stripe-Version: 2026-09-30.endive
Content-Type: application/json

{"approved": true, "amount": 1500, "metadata": {"rule": "partial_balance"}}

The Stripe-Version header is required. Leave it out or send an invalid version and Stripe records webhook_error, however correct the body is. The amount field only counts when pending_request.is_amount_controllable is true.

While the request is pending, the top-level amount is 0 and approved is false. The real figures sit in pending_request, alongside merchant_currency and network_risk_score. Code that reads authorization.amount at this point sees zero, which passes every limit check you have.

There is no decline reason to return. You send "approved": false and, if you want a record, put your reason in metadata. Incremental authorisations arrive as a fresh issuing_authorization.request on the same iauth_ ID, with pending_request.amount set to the increment. Dedupe on the event ID, not the authorisation ID, or you will silently drop every hotel and car-hire increment.

Stripe records the outcome in request_history[].reason. The 2026-09-30 spec has 21 values, including webhook_approved, webhook_declined, webhook_timeout, webhook_error and network_fallback. Stripe warns against judging integration health by approved. The rate of webhook_timeout and webhook_error is the better signal.

Lithic Auth Stream Access (ASA): Result Codes and Retries

Lithic enrols your responder with POST /v1/responder_endpoints and type: "AUTH_STREAM_ACCESS". The older /v1/auth_stream/enroll endpoints have been removed from the SDKs.

{
  "token": "",
  "result": "APPROVED",
  "approved_amount": 1500
}
result is the only required field. Its enum has ten values: APPROVED, AVS_INVALID, CARD_PAUSED, INSUFFICIENT_FUNDS, UNAUTHORIZED_MERCHANT, VELOCITY_EXCEEDED, DRIVER_NUMBER_INVALID, VEHICLE_NUMBER_INVALID, SUSPECTED_FRAUD and CHALLENGE. Anything other than APPROVED or CHALLENGE declines, and CHALLENGE is only valid for cardholder-initiated transactions.

Signing is the trap. ASA requests carry no webhook-signature headers until you call GET /v1/auth_stream/secret once. After that they arrive in Standard Webhooks form: webhook-id, webhook-timestamp and an HMAC-SHA256 over id.timestamp.body. Build against the sandbox before fetching it and every request is unsigned, which is how a "verify if present" shortcut reaches production.

Lithic retries once, immediately, on a network failure or a 5xx, so the same request can arrive twice. It does not retry a 4xx or a 2xx with a bad body. Dedupe on token. Partial approval through approved_amount is in cents of the settlement currency, excludes the acquirer fee, and must not exceed the request (the exception is $1 fuel checks on MCC 5542). It only works when pos.terminal.partial_approval_capable is true; otherwise the authorisation is declined. ATM, credit and cashback transactions can't be partially approved.

On a timeout the transaction is declined with detailed_results set to CUSTOMER_ASA_TIMEOUT. An unparseable body gives MALFORMED_ASA_RESPONSE, and a result outside the enum gives CUSTOM_ASA_RESULT. For BALANCE_INQUIRY messages you must return balance, or Lithic reports $0 to the network.

Marqeta JIT Funding: Gateway Response, 402 and timeout_millis

Marqeta has two modes. In Managed JIT, Marqeta applies your spend controls and decides. In Gateway JIT, it applies the controls and then asks your gateway, which must pass Marqeta certification and authenticate requests with basic auth.

Approve with 200, deny with 402. Both need a body:

{
  "jit_funding": {
    "token": "",
    "method": "pgfs.authorization",
    "user_token": "",
    "amount": 42.50,
    "decline_reason": "INSUFFICIENT_FUNDS"
  }
}

The decline_reason enum has 25 values. Two of them are worth wiring up early: SOFT_DECLINE_AUTHENTICATION_REQUIRED and SOFT_DECLINE_PIN_REQUIRED, which ask for step-up rather than refusing outright. amount must equal the request unless the message has partial_approval_capable set.

The method field tells you what you are deciding. Nine methods need an answer, mapped in the table further down. Others arrive only as webhook notifications: pgfs.force_capture, pgfs.refund, and the stand-in variants pgfs.authorization.standin, pgfs.auth_plus_capture.standin and pgfs.refund.standin.

The deadline is three seconds, set by timeout_millis on POST /fundingsources/programgateway. It accepts 1000 to 3000 and defaults to 3000, so you can shorten it but never extend it. On timeout or error Marqeta declines, unless Commando Mode is configured. COMMANDO_AUTO stands in for you when real_time_standin_criteria matches, with separate flags for include_connection_errors, include_response_timeouts and include_application_errors. You set it up through your Marqeta representative, not the API.

Adyen Relayed Authorisation: Decision on Error

Adyen runs validations, then your transaction rules, then the relayed webhook. A transaction rule decline means no webhook. The response is small:

{
  "authorisationDecision": {
    "status": "Refused",
    "refusalReason": "ledger_insufficient_funds"
  },
  "reference": "auth-7f3a"
}
refusalReason is a free string, not an enum, and the response schema has no amount field, so relayed authorisation can't partially approve. The relayed authorisation page gives 2000 ms. The validation-checks page says stand-in triggers after 1500 ms. Build for 1500.

Adyen makes the fallback explicit. Under Decision on error you set approve or decline separately for connection errors and for invalid responses, and 4xx and 5xx replies follow it. The fallback shows up as validation type relayedAuthorisationStip.

What Happens When an Authorisation Webhook Times Out?

Your platform's deadline sits inside the network's. Mastercard's documentation for its Mastercard Processing debit product says the processor has at most 7 seconds to answer Mastercard, and its own stand-in triggers if the issuer hasn't replied within 4 seconds. Afterwards the issuer receives 0120 advice messages for what was approved. I found no primary Visa figure, so I won't quote one.

The case that breaks ledgers is approving too late. You decide to approve, write a hold and respond at 2.3 seconds. Stripe has already applied your timeout setting. Lithic has declined. Marqeta has declined and set gateway_log.timed_out to true, and its docs say plainly that reversing your hold is your job. The cardholder saw a decline, and your ledger shows money reserved.

The reverse is just as real. You declined or didn't answer, and the network approved on stand-in. Each platform reports that differently:

PlatformPlatform-side fallbackNetwork stand-in signal
StripeTimeout setting or Autopilot; webhook_timeout / webhook_errornetwork_fallback (dedicated BIN with Autopilot)
LithicDecline; CUSTOMER_ASA_TIMEOUTAUTHORIZATION_ADVICE event
MarqetaDecline or Commando; standin_by: COMMANDO_AUTOstandin_by: NETWORK, standin_reason such as issuer_timeout
AdyenDecision on error; relayedAuthorisationStipbalancePlatform.transfer.updated, reason: schemeAdvice

Adyen "always defers to the scheme's advice", so an adviceAuthorised event is a debit you must post. For most Lithic programmes the networks stand in to decline, and only certain enterprise clients can change that.

Which Card Transactions Skip the Authorisation Webhook?

MessageStripeLithic ASAMarqeta Gateway JITAdyen
PurchaseYesAUTHORIZATIONpgfs.authorizationYes
IncrementalYes, same iauth_Not documentedpgfs.authorization.incrementalNot documented
$0 card verificationNo, approved if basic checks passNot documentedpgfs.authorization.account_verificationNot documented
Balance inquiryNot documentedBALANCE_INQUIRYpgfs.balanceinquiryNot documented
RefundNo, default logicCREDIT_AUTHORIZATION if enabledpgfs.refund.authorizationNotification only
Force captureNo, Transaction with authorization: nullNot an ASA typeNotification onlyNot documented

Force captures are the big one. A merchant can capture without a valid authorisation (offline in-flight sales are the classic case), and Stripe states that spending controls and real-time controls "don't apply for capture". Your ledger has to accept debits it never approved.

Rule declines are the quiet one. At all four providers, a processor-side rule decline never reaches you, so webhook-based decline analytics undercount. On Stripe, a card with no spending_limits gets a default of $500 a day, and there is a fixed $10,000 cap per authorisation. Lithic's Auth Rules V2 and MCC-based blocks behave the same way.

Should a Card Authorisation Webhook Fail Open or Closed?

My view: decline on invalid responses always, and choose the timeout behaviour by product. An invalid response is your bug, and approving on it hides a broken deploy until money has left. A timeout is often infrastructure, and for a pre-funded corporate card a declined fuel purchase can cost more in trust than a small overdraft risk.

Only Adyen exposes that split as a plain setting today. Marqeta's Commando flags get close, after a conversation with your account team. My prediction is that the webhook becomes the minority decision path within two years. Processor-side rules such as Lithic's TYPESCRIPT_CODE rules, Stripe Autopilot and Marqeta Real-Time Decisioning will take the routine calls, and your server will be asked only when the answer depends on your ledger.

What This Means for Card Issuing Teams

1. Budget half the deadline. Aim for a p99 under 1 second on Stripe and Adyen, 1.5 seconds on Marqeta, and Lithic's own 3-second target. 2. Make the decision from one read. Read balance and limits in one keyed lookup, and put a hard sub-timeout on any inline fraud call. 3. Write provisional holds. Key them on the provider's request ID, confirm them only on the platform's final event, and sweep unconfirmed ones. 4. Dedupe on the right key. That means the Stripe event ID (not iauth_), Lithic's token, and Marqeta's jit_funding.token. Marqeta doesn't document a key, so that last one is my suggestion. The idempotency patterns for payment APIs apply here too. 5. Never answer a business decline with a 5xx. Lithic retries it, Marqeta treats it as an application error, and on Adyen it follows Decision on error, which may be set to approve. 6. Alert on fallback reasons, not decline rate. Watch webhook_timeout, CUSTOMER_ASA_TIMEOUT, gateway_log.timed_out and relayedAuthorisationStip. 7. Let some debits go negative. Force captures, stand-in advices and Adyen scheme advice will arrive whatever your balance says. 8. Test the failure paths. Use Stripe's create_force_capture, Lithic's /v1/simulate/authorization_advice, and a deliberate sleep in your handler to hit each timeout branch.

Key Takeaways

  • Deadlines: Stripe 2 s, Adyen 2000 ms (possibly 1500), Marqeta 3 s and lowerable, Lithic 6 s.
  • Lithic and Marqeta decline on timeout by default. Stripe and Adyen let you choose.
  • Lithic ASA requests are unsigned until you fetch the secret.
  • Force captures, refunds on Stripe, rule declines and network stand-in never ask your server, but they still move money.
  • The real ledger bug is the approval that arrived after the deadline.
I'm Tom Wang, and I write about the engineering underneath payment rails. Providers change these settings more often than the networks do, so check current docs before hard-coding a number.