503 with no clear outcome. The charge may or may not have reached the card network — resolve it before you do anything else.
TL;DR — No response, or a
5xx? Replay the identical request with the same key — request_id for a purchase, authorize, or refund, operation_id for a capture or void — even after a 5xx that says retry_allowed: false (switch-timeout, database-unavailable). A same-key replay is a lookup, not a resend: RadiumOne returns what it recorded, including the transaction id. For a capture, void, or referenced refund that was sent but whose outcome wasn’t recorded, it asks the card network for the stored outcome and sends the message only if the network never received it. A replay can return PENDING or REVERSAL_PENDING until the outcome settles; the confirming webhook tells you the final outcome. A capture that timed out after it may have reached the network is reversed — the capture, never the authorization: its retry gets 409 tx:invalid-state-transition until the hold is back to AUTHORIZED, then is sent as a new capture attempt. Never mint a new key for the same attempt.When this happens
- Your HTTP client times out waiting for a response — the request may have already reached RadiumOne and the acquirer. You don’t have a transaction
idyet in this case — the response that would have carried it never arrived. - RadiumOne’s own upstream connection to the payment switch times out, returned as
503 urn:radiumone:payment-gateway:switch-timeoutwithretry_allowed: false. The outcome is genuinely indeterminate: the charge may have been forwarded to the acquirer host before the timeout.
What you see
Recovery path
- Capture or void with no response or any
5xx— includingretry_allowed: false: replay the identical body with the sameoperation_id, with backoff. RadiumOne returns the recorded outcome; if the capture or void was sent but its outcome wasn’t recorded, it asks the card network for the stored outcome instead of sending it again, and sends it only if the network never received it. Two timeouts work differently. A capture that timed out after it may have reached the card network is reversed — the capture, never the authorization: while that reversal is open (REVERSAL_PENDING), the retry gets409 tx:invalid-state-transition— wait and retry; once it clears, the hold is back toAUTHORIZEDand the retry is sent as a new capture attempt. A void that timed out is reversed too: while that reversal is open, the retry gets409 transaction:void-reversal-pending(retry_allowed: true) — wait and retry; once it clears, the sale is back toCAPTUREDand the retry is sent as a new attempt. A capture or void that timed out before it left RadiumOne is sent as a new attempt — nothing was sent the first time. - Purchase, authorize, standalone refund (
POST /v1/transactions/refund), or referenced refund (POST /v1/transactions/refund/{transaction_id}) with no response or any5xx— includingretry_allowed: false: replay the identical body with the samerequest_id, with backoff. The replay is a lookup: it returns the stored result whatever it is, including the transactionid, and never sends it twice (a request refused before it reached the card network, for example withdevice-settlingordevice-busy, is run again on the same transaction — it was never sent) (a referenced refund whose outcome wasn’t recorded is checked with the card network first, like a capture). It can returnPENDINGorREVERSAL_PENDINGuntil the outcome settles. - If the replay itself comes back
409 duplicate-body-mismatch, the resend didn’t match the original attempt byte-for-byte — resend the stored original body instead. If a capture, void, or refund with a different key comes back409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt, an earlier one on the same transaction is still unresolved: resend the request named bypending_operation_idfirst (see Replays and idempotency conflicts). - Any other
4xxon the replay means something else is wrong with the request — fix it before you retry again. - If the replayed response is
2xxwith a final status —CAPTURED,AUTHORIZED,VOIDED,DECLINED,REVERSED, orAUTH_EXPIRED— branch on it and stop.REVERSEDmeans the charge was reversed and nothing was kept: start a new attempt with a newrequest_idif the shopper still wants to pay. (A capture replay that returns the transaction stillAUTHORIZEDmeans the capture didn’t go through — see Handle capture failures.) - If it’s
2xxwithPENDINGorREVERSAL_PENDING, the outcome hasn’t settled — keep theidfrom that response and wait for the confirming webhook (recommended — it pushes the outcome to you); call status inquiry instead if you don’t have webhooks set up or need an answer right now. - If it’s
2xxwithFAILEDon a purchase, the card network’s host didn’t approve it, so nothing was charged: retry with a newrequest_idif the shopper still wants to pay. That includesresponse_code: "99"when the payment network was too busy to take the request — replaying the same key only returns thatFAILEDagain (Rate limits). The exception isresponse_code: "**": the payment network rejected the request itself, so a newrequest_idfails the same way — fix the request first. A purchase whose outcome was genuinely unknown after an upstream timeout isn’t leftFAILED— RadiumOne reverses it instead (REVERSAL_PENDING→REVERSED, see Understand automatic reversals), so keep the status check forPENDINGandREVERSAL_PENDING. For any other operation, confirm with a statusGETbefore a new attempt with a new key. - If you still get no response after a few tries, or you can’t reproduce the exact original body, don’t guess — wait for the confirming webhook instead, or contact support with your
order_referenceand approximate timestamp if you need it sooner. - Never send a new
request_idto “retry faster” — that’s the path that risks a duplicate charge.
What to do
1
Don't create a new request
Never mint a new
request_id (or operation_id) just because the first attempt was slow or came back as 503. Reuse the same key for whatever you do next.2
Replay the identical request to recover the transaction id
If you don’t have a transaction The replay is a lookup: RadiumOne answers it from what it recorded — the stored transaction, whatever its status, including its
id yet — the usual case after a client-side timeout, switch-timeout, or database-unavailable — replay the exact same purchase or authorize body with the exact same request_id first (API reference):id (except a request refused before it reached the card network, which is run again on the same transaction) — and never sends the payment to the card network again, so you can repeat it even when the 5xx said retry_allowed: false (urn:radiumone:payment-gateway:switch-timeout, urn:radiumone:payment-gateway:database-unavailable). Until the outcome settles it can return PENDING or REVERSAL_PENDING (RadiumOne is reversing a charge it couldn’t confirm). The same goes for a standalone refund (POST /v1/transactions/refund) and a referenced refund with the same request_id, and for a capture or void with the same operation_id: if a capture, void, or referenced refund was sent but its outcome wasn’t recorded, the replay recovers that outcome from the card network instead of sending the operation again. A capture or void that timed out follows step 1 of the Recovery path instead.3
Once you have the id, let the webhook confirm the outcome — or check now with status inquiry
If you have a webhook endpoint registered, the confirming event (
payment.*, authorization.*, refund.*) arrives without you polling anything — this is the recommended path, and it’s what Webhooks overview assumes. If you don’t use webhooks, or you need an answer right now rather than waiting, call the status-inquiry endpoint instead — it never writes a new row, so it’s always safe to call on demand. While it reads PENDING or REVERSAL_PENDING, poll every 60 seconds — see Poll until the outcome settles (API reference):4
No id and the replay didn't resolve it? Wait for the webhook or contact support
If you can’t reproduce the exact original body (for example, you lost the
amount from a form submission), a replay isn’t possible. RadiumOne doesn’t expose a list-by-order_reference lookup, so wait for the confirming webhook (payment.*, authorization.*, refund.*), or contact support with your order_reference and approximate timestamp.5
Branch on the final status
Any 2xx response is a result you must branch on
status — never on response_code (that’s the verbatim host/acquirer code; useful for support tickets, not for your app logic).6
Reconcile via webhook if you still can't resolve it
If every synchronous option above is exhausted, wait for the confirming webhook (
payment.*, authorization.*, refund.*) instead of guessing — see Webhooks overview.Prevent it
- Set a client-side HTTP timeout longer than a few seconds — a request that’s merely slow at the switch shouldn’t look identical to a dropped connection on your side.
- Build the replay-with-same-key path for every payment operation (purchase, authorize, capture, void, and both refunds), and the handling for
409 tx:followup-outcome-in-doubt, into your integration before you go live, not during your first production incident.
Test it
See Test your integration for simulated timeout scenarios.Related
Prevent duplicate payments
The cross-product guide to avoiding duplicate charges.
Check a transaction's status
Status inquiry and timeout recovery, in depth.
Problem format and retries
The full retry-rules reference.
Understand automatic reversals
What happens if the switch timeout turns into a reversal.