TL;DR — Same key, same body → the original result, whatever its status (
201/200, even PENDING), unless the first request was refused before it reached the card network (for example device-settling): that one is run again. Same key, different body → 409. Which 409 depends on the key: request_id compares the body; operation_id never does. A capture, void, or refund with a new key while an earlier one on the same transaction is unresolved → 409 tx:followup-outcome-in-doubt: resend the earlier one first.When this happens
- A byte-identical replay: the same
request_id(purchase, authorize, refund, standalone refund) oroperation_id(capture, void) with the same body. This is the safe, expected retry path after a timeout. Balance inquiry also takes arequest_idfield, but it’s not deduplicated — see the note below. - A body-mismatch replay: the same
request_idwith a different body —409 urn:radiumone:payment-gateway:transaction:duplicate-body-mismatch. - A cross-operation replay: the same
request_idfirst used for one operation type (say, a purchase) and then sent to a different operation (say, a referenced refund) — also409 urn:radiumone:payment-gateway:transaction:duplicate-body-mismatch. Arequest_idis scoped to the operation type it was first used for. - A conflicting operation replay: the same
operation_idreused for a different operation type on the same transaction (for example, a capture’s key reused for a void) —409 urn:radiumone:payment-gateway:tx:duplicate-operation. - A new follow-up while an earlier one is unresolved: a capture, void, or refund with a different key on a transaction whose earlier capture, void, or refund was sent but has no recorded outcome (for example, a
503came back and you never replayed it) —409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt.
How the gateway decides
- A request arrives carrying a
request_idoroperation_id. - If your merchant account hasn’t used that key before, the gateway creates a new transaction.
- If the key was used before and it’s a
request_id(purchase, authorize, refund, standalone refund): the gateway comparesamount,card,channel,metadata, andorder_referenceagainst the first attempt, and confirms the key was used for the same operation type both times. It does not comparethree_dsorloyalty— changing either on a retry replays the original silently instead of failing.- Match, and the first attempt already finished → the original result, at the original HTTP status — whatever the status, including
DECLINEDorFAILED. - Match, and the first attempt was refused before it reached the card network (for example
409 device-settlingor409 device-busy) → the request is run again on the same transaction, not returned — no second transaction is created. That’s why you resend the same key once the terminal has settled or is free. Routing may pick a different terminal or acquirer this time. - The first attempt was refused before any transaction was recorded (for example
422 routing:no-acquirer-availableor503 routing:acquirer-circuit-open) → the request is run as new. - Match, and the first attempt is still processing → the existing transaction comes back, usually
PENDING, with itsid— not a new transaction. Poll status or wait for the webhook. - Mismatch on any of the compared fields, or the same key reused for a different operation type →
409 duplicate-body-mismatch.
- Match, and the first attempt already finished → the original result, at the original HTTP status — whatever the status, including
- If the key was used before and it’s an
operation_id(capture, void): the gateway only checks whether it’s the same operation type on the same transaction — the body is never compared.- Same operation type → the original result, at the original HTTP status, regardless of what you sent this time.
- Same operation type, and the earlier capture timed out after it may have reached the card network → RadiumOne reverses that capture (never the authorization). While the reversal is open (
REVERSAL_PENDING) the retry gets409 tx:invalid-state-transition; once it clears, the hold is back toAUTHORIZEDand the retry is sent as a new capture attempt. - Same operation type, and the earlier void timed out → while RadiumOne reverses that void, the retry gets
409 transaction:void-reversal-pending(retry_allowed: true). Once the reversal clears, the sale is back toCAPTUREDand the retry is sent as a new attempt. - Same operation type, and the earlier capture or void timed out before it left RadiumOne → it’s sent as a new attempt. Nothing was sent the first time.
- A different operation type reusing the key →
409 tx:duplicate-operation.
Referenced refunds match a narrower set of fields: the same original transaction, the same
amount, and a key already used for a refund — reason isn’t compared. The replay check runs before the batch/window/cap gates, so a retry always replays (never 422), even if another refund changed the refundable amount in between — unless the first attempt was refused before it reached the card network, which is run again. Because a DECLINED or FAILED refund replays too, retry after a decline with a new request_id, not the same one. A wrong transaction_id in the path returns 404 before the replay check runs.What you see
What to do
1
Resend byte-identical for a genuine retry
If you’re retrying after a timeout or a The response is the original result, at the original HTTP status, so you can repeat it — even after a
5xx, resend the exact stored body with the exact same key (API reference):5xx with retry_allowed: false (switch-timeout, database-unavailable). The replay is a lookup, not a resend, and it can return PENDING or REVERSAL_PENDING until the outcome settles. The exceptions above are safe too: a request refused before it reached the card network was never sent, and a timed-out capture or void is sent again only after its reversal clears (until then, 409 tx:invalid-state-transition or 409 transaction:void-reversal-pending). For a capture, void, or referenced refund that was sent but whose outcome wasn’t recorded, RadiumOne recovers the outcome from the card network instead of sending it again, and sends it only if the network never received it. See Handle timeouts and unknown outcomes.2
Fix the body if you get a mismatch
A
409 duplicate-body-mismatch means a request_id was reused with a body that doesn’t match the first attempt. Don’t retry as-is — resend the original body, or mint a new request_id if this is genuinely a different attempt (a different card, a different amount).3
Resend the pending request if an earlier follow-up is in doubt
A
409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt means an earlier capture, void, or refund on the same transaction reached the card network but RadiumOne has no recorded outcome for it, so it won’t send another operation that could apply on top of it. The problem body names the earlier request:pending_operation—CAPTURE,VOID, orREFUNDpending_operation_id— its key: theoperation_idof the capture or void, or therequest_idof the refund
pending_operation_id) and the same body you stored for it. Its replay recovers the outcome, and then you can send yours with its own key, if you still need it. Resending your new request unchanged returns the same 409 (retry_allowed: false) until the pending one is resolved.If you no longer have the pending request, RadiumOne resolves it on its own in the background, usually within about 20 minutes. It asks the card network what happened to the earlier operation, and you get a webhook whenever the network has a record of it:- approved → the success event for that operation;
- declined → its failure event;
- outcome still unknown → its failure event, and RadiumOne starts a reversal;
- no record (the operation never reached the network) → no webhook: nothing happened.
409 stays until they resolve it. A refusal that clears on its own keeps being retried. There’s no fixed maximum time.Check the transaction with the status inquiry, then retry yours with its own key. If it still returns this 409 60 minutes after you sent the earlier request, contact support.4
Use one key per attempt, and one per operation
Generate one
request_id per order attempt and one operation_id per operation (a capture and a later void on the same transaction are two different operations — they each need their own key). Reusing an old key for a different attempt or a different operation type is what causes a conflict in the first place.Prevent it
- Generate the idempotency key once per attempt, before you send the first request, and reuse that exact value for every retry of that same attempt.
- Keep a local record of which key you used for which order attempt (and which operation), so a retry — even after a restart — reuses the right one.
- Never derive a key from mutable data (a timestamp, a request counter) that changes between retries — that guarantees a mismatch instead of a safe replay.
Test it
See Test your integration and Body mismatch for scenario coverage.Related
Prevent duplicate payments
The cross-product guide to avoiding duplicate charges.
Charge or authorize a payment
Idempotency rules for purchase and authorize.
Capture an authorization
Idempotency on
operation_id.Problem format and retries
The full retry-rules reference.