Skip to main content
Your request to create, capture, void, or refund a transaction gets no response, or a 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 id yet 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-timeout with retry_allowed: false. The outcome is genuinely indeterminate: the charge may have been forwarded to the acquirer host before the timeout.

What you see

retry_allowed: false here doesn’t mean “give up” — it means don’t send the operation again. The charge may already have reached the card network. A retry with a new key is the worst option: it risks a duplicate charge if the original request landed. A replay with the same key isn’t a resend, so it’s how you recover the outcome: RadiumOne answers a purchase, authorize, or standalone refund from what it recorded and never runs it again, and for a capture, void, or referenced refund with no recorded outcome it looks up the outcome the card network stored before it sends anything.

Recovery path

  1. Capture or void with no response or any 5xx — including retry_allowed: false: replay the identical body with the same operation_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 gets 409 tx:invalid-state-transition — wait and retry; once it clears, the hold is back to AUTHORIZED and the retry is sent as a new capture attempt. A void that timed out is reversed too: while that reversal is open, the retry gets 409 transaction:void-reversal-pending (retry_allowed: true) — wait and retry; once it clears, the sale is back to CAPTURED and 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.
  2. Purchase, authorize, standalone refund (POST /v1/transactions/refund), or referenced refund (POST /v1/transactions/refund/{transaction_id}) with no response or any 5xx — including retry_allowed: false: replay the identical body with the same request_id, with backoff. The replay is a lookup: it returns the stored result whatever it is, including the transaction id, and never sends it twice (a request refused before it reached the card network, for example with device-settling or device-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 return PENDING or REVERSAL_PENDING until the outcome settles.
  3. 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 back 409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt, an earlier one on the same transaction is still unresolved: resend the request named by pending_operation_id first (see Replays and idempotency conflicts).
  4. Any other 4xx on the replay means something else is wrong with the request — fix it before you retry again.
  5. If the replayed response is 2xx with a final status — CAPTURED, AUTHORIZED, VOIDED, DECLINED, REVERSED, or AUTH_EXPIRED — branch on it and stop. REVERSED means the charge was reversed and nothing was kept: start a new attempt with a new request_id if the shopper still wants to pay. (A capture replay that returns the transaction still AUTHORIZED means the capture didn’t go through — see Handle capture failures.)
  6. If it’s 2xx with PENDING or REVERSAL_PENDING, the outcome hasn’t settled — keep the id from 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.
  7. If it’s 2xx with FAILED on a purchase, the card network’s host didn’t approve it, so nothing was charged: retry with a new request_id if the shopper still wants to pay. That includes response_code: "99" when the payment network was too busy to take the request — replaying the same key only returns that FAILED again (Rate limits). The exception is response_code: "**": the payment network rejected the request itself, so a new request_id fails the same way — fix the request first. A purchase whose outcome was genuinely unknown after an upstream timeout isn’t left FAILED — RadiumOne reverses it instead (REVERSAL_PENDING → REVERSED, see Understand automatic reversals), so keep the status check for PENDING and REVERSAL_PENDING. For any other operation, confirm with a status GET before a new attempt with a new key.
  8. 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_reference and approximate timestamp if you need it sooner.
  9. Never send a new request_id to “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 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):
The replay is a lookup: RadiumOne answers it from what it recorded — the stored transaction, whatever its status, including its 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.

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.
Last modified on October 25, 2026