Skip to main content
You resent a request with the same idempotency key — either on purpose, as a retry, or by accident — and want to know what comes back. Looking for what to do about an actual double charge instead? See Handle duplicate payments.
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) or operation_id (capture, void) with the same body. This is the safe, expected retry path after a timeout. Balance inquiry also takes a request_id field, but it’s not deduplicated — see the note below.
  • A body-mismatch replay: the same request_id with a different body — 409 urn:radiumone:payment-gateway:transaction:duplicate-body-mismatch.
  • A cross-operation replay: the same request_id first used for one operation type (say, a purchase) and then sent to a different operation (say, a referenced refund) — also 409 urn:radiumone:payment-gateway:transaction:duplicate-body-mismatch. A request_id is scoped to the operation type it was first used for.
  • A conflicting operation replay: the same operation_id reused 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 503 came back and you never replayed it) — 409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt.

How the gateway decides

  1. A request arrives carrying a request_id or operation_id.
  2. If your merchant account hasn’t used that key before, the gateway creates a new transaction.
  3. If the key was used before and it’s a request_id (purchase, authorize, refund, standalone refund): the gateway compares amount, card, channel, metadata, and order_reference against the first attempt, and confirms the key was used for the same operation type both times. It does not compare three_ds or loyalty — 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 DECLINED or FAILED.
    • Match, and the first attempt was refused before it reached the card network (for example 409 device-settling or 409 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-available or 503 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 its id — 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.
  4. 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 gets 409 tx:invalid-state-transition; once it clears, the hold is back to AUTHORIZED and 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 to CAPTURED and 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.
Balance inquiry also takes a request_id field, but it isn’t an idempotency key — there’s no dedup or replay store, so every call re-queries the rewards host, even with the same request_id.

What you see

What to do

1

Resend byte-identical for a genuine retry

If you’re retrying after a timeout or a 5xx, resend the exact stored body with the exact same key (API reference):
The response is the original result, at the original HTTP status, so you can repeat it — even after a 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, or REFUND
  • pending_operation_id — its key: the operation_id of the capture or void, or the request_id of the refund
The fastest way out is to resend that pending request — the same key (from 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.
If the network refuses the earlier operation for a reason that won’t clear on its own (for example, the capture window has passed), RadiumOne hands it to its operations team after about an hour, and this 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.

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