Skip to main content
Void cancels a CAPTURED transaction — a purchase, a captured authorization, or a refund — before its settlement batch closes, so its funds never settle.
You can’t void an uncaptured authorization. A void of an AUTHORIZED hold is refused with 409 tx:invalid-state-transition before anything is sent, and no webhook follows. If you don’t want to capture a hold, leave it: it’s released when its capture window runs out, and you receive authorization.expired. Once you’ve captured it, you can void it like any other payment while its batch is open.
This request requires a valid access token. See Authentication to obtain one with POST /v1/auth/token before you continue.

Void or refund, never both

Void while the settlement batch is OPEN. Refund once it’s CLOSED. You can’t do either the other way around:
  • Voiding a transaction whose batch has already closed returns 409 urn:radiumone:payment-gateway:tx:void-on-non-open-batch.
  • Refunding a transaction whose batch is still open returns 409 urn:radiumone:payment-gateway:tx:refund-on-open-batch.
The boundary is the settlement batch closing, not the card network settling with the issuer. Check GET /v1/transactions/{id}/status or a settlement.* webhook if you’re unsure which state you’re in. See Resolve void and refund conflicts if you hit either error.

Steps

1

Void the transaction

Send the transaction’s id. An optional reason (up to 200 characters) is stored for your own records. API reference.
If the call times out, see Handle timeouts and unknown outcomes. If it conflicts with the batch state or an in-flight reversal, see Resolve void and refund conflicts and Understand automatic reversals.

Handle the result

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).
After a timeout or a 5xx, replay with the same key. For every payment operation — purchase, authorize, capture, void, and both refunds — a replay of the identical request with the same request_id or operation_id is a lookup, not a resend, so it’s safe even after a 5xx that says retry_allowed: false (switch-timeout, database-unavailable). RadiumOne returns the outcome it recorded. If a capture, void, or referenced refund was sent but its outcome wasn’t recorded, RadiumOne asks the card network for the stored outcome instead of sending it again, and sends it only if the network never received it — so nothing is applied twice. A replay can return PENDING or REVERSAL_PENDING until the outcome settles. A request RadiumOne refused before it reached the card network (for example with device-settling or device-busy) is run again on the same transaction instead of returning a stored result — no second transaction is created. A capture that timed out after it may have reached the card network is reversed — the capture, never the authorization under it: while that reversal is open (REVERSAL_PENDING), a same-operation_id 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. A capture that timed out before it left RadiumOne is sent as a new attempt on a same-operation_id retry — nothing was sent the first time. A void that timed out is reversed too: while that reversal is open, a retry gets 409 transaction:void-reversal-pending (retry_allowed: true); once it clears, the sale is back to CAPTURED and the retry is sent as a new attempt. While that earlier capture, void, or refund is unresolved, a follow-up with a different key on the same transaction gets 409 urn:radiumone:payment-gateway:tx:followup-outcome-in-doubt: resend the pending request first. See Handle timeouts and unknown outcomes.
Balance inquiry also takes a request_id field, but it isn’t an idempotency key — there’s no dedup or replay store. Every call re-queries the rewards host, even with the same request_id.
Keys are 8–64 characters, [a-zA-Z0-9-] only, unique per merchant account. Generate one key per order attempt and persist it to your database before you send the first request — never mint a new key just to retry the same attempt. See Prevent duplicate payments.
PENDING means the outcome isn’t known yet — most often after a processor timeout. Don’t assume success or failure. Recover it one of two ways:
  1. Wait for a webhook (payment.*, authorization.*, refund.* — see Webhook event types).
  2. Poll GET /v1/transactions/{id}/status — it returns the transaction as RadiumOne holds it. Poll every 60 seconds while it reads PENDING or REVERSAL_PENDING, and contact support if it isn’t final 60 minutes after your server sent the original request; INCONSISTENT means stop and contact support; anything else is final. See Check a transaction’s status.
If you don’t have the transaction id yet — a client-side timeout before the first response arrived — replay the same purchase, authorize, or refund with the same request_id and body. The replay is a lookup, not a resend: it returns the stored transaction and its id, whatever status it’s reached, including PENDING or REVERSAL_PENDING. A capture or void replayed with the same operation_id works the same way, and for a capture, void, or referenced refund whose outcome wasn’t recorded, RadiumOne checks with the card network before sending anything. Never re-submit with a new idempotency key just because the first attempt is slow — that risks a second charge for the same order. Void responses are 200, including retries — a replayed void with the same operation_id returns the same 200 result. If the outcome is unknown — no response, or any 5xx, even one that says retry_allowed: false — replay the identical void with the same operation_id. The replay is a lookup, not a resend: RadiumOne returns the outcome it recorded, and if the void reached the card network but the outcome wasn’t recorded, it asks the network for the stored outcome instead of voiding again. It sends the void only if the network never received it. If the void timed out after it may have reached the card network, RadiumOne reverses the void itself. While that reversal is open, a retry gets 409 transaction:void-reversal-pending (retry_allowed: true) — wait and retry. Once it clears, the sale is back to CAPTURED and your retry is sent as a new attempt. RadiumOne may also void the sale again on its own at that point; your retry then returns that void. A void that timed out before it left RadiumOne is sent as a new attempt. Never mint a new operation_id for the same void attempt.
operation_id replays never compare the request body — a retry with the same operation_id returns the original result even if something about the request differs. Use a new operation_id for a genuinely new operation. Reusing a void’s operation_id for a capture on the same transaction is rejected with 409 urn:radiumone:payment-gateway:tx:duplicate-operation, not treated as a replay.

Errors

Full HTTP status and meaning for each of these is defined once on Problem format and retries — this list is only the void-specific nuance:

Reversal-pending

If a void times out after it may have reached the card network, RadiumOne reverses the void, not the sale. The sale reads REVERSAL_PENDING while that reversal is open, then returns to CAPTURED — the void didn’t happen. RadiumOne may then void the sale again on its own; you can also retry your void with the same operation_id (see Handle the result). Check the final state with the confirming webhook or the status inquiry.

Test your integration

See Test your integration for open-batch and closed-batch scenarios.

Go-live notes

  • Check the transaction’s status before voiding if you’re not sure whether it’s captured or whether its batch already closed.
  • Don’t build a “cancel the hold” path on void: an uncaptured authorization lapses on its own at the end of its capture window.
  • Replay a timed-out void, or one that got a 5xx, with the same operation_id, never a new one.
  • Review the full go-live checklist.

Next steps

Refund a payment

Reverse a payment once its batch has closed.

Payment lifecycle

See the full transaction state diagram.
Last modified on October 25, 2026