All integrations
- You’ve run the relevant scenarios in Test your integration, including idempotent replay, body mismatch, and timeout recovery.
- Every create-type request path retries a timeout,
5xx, orPENDINGresult with the same idempotency key — never a new one. - Your code branches only on
status(never on the HTTP status code alone, never onresponse_code) — see Problem format and retries. - You confirm the payment result server-side — a status inquiry or a verified webhook — before fulfilling an order. Never from a client redirect or the browser alone.
- If you refund payments, you’ve requested enablement for the acquirer channel(s) you refund through — unlike most gateways, refunds are disabled by default on RadiumOne. See Refunds require enablement.
- You’ve swapped every
_test_key and sandbox host for its_prod_/ production equivalent — see Moving to production. - Your webhook signature check passes a known-answer test before you point it at a live endpoint — see Verify webhook signatures.
- Your webhook handler dedupes on event
idand doesn’t assume delivery order — see Retries, ordering and duplicates. - You handle the failure scenarios in Handle Payments API failures.
Duplicate payments
- You persist
request_id(oroperation_id) to your database before sending the first request, and reuse that same key on every retry of the same order attempt — never a new one just because a call was slow. Any payment operation with an unknown outcome (purchase, authorize, capture, void, or refund) is replayed with the same key — a lookup, not a resend — and you handle409 tx:followup-outcome-in-doubtby resending the pending request it names first. - You generate one
order_referenceper checkout session attempt, and store the resultingtransaction_idin your own order record — not theorder_referenceitself. - You check your own order state before creating a new checkout session —
order_referenceonly dedupes within the session’s TTL; after it expires, a retry creates a new session even for an already-paid order. - Your Elements integration disables the Pay button while a submission is in flight — the SDK’s submit throttle isn’t a substitute for this.
- Your webhook handler dedupes on the event
idbefore crediting or fulfilling anything a second time. - You’ve read Prevent duplicate payments and know which of the checks above apply to your integration.
Hosted checkout, no 3D Secure
Hosted checkout, no 3D Secure
- Redirect to hosted checkout works end-to-end in sandbox with approval, decline, and timeout test cards.
- Embedded mode only: your
postMessagehandler covers everyCHECKOUT_*event you rely on, and doesn’t wait forCHECKOUT_CANCELLED(never emitted) — see Embed hosted checkout. - Fail-closed redirect verification: if you’ve configured a redirect
secret, your return-page handler treats a missing or invalid
sigas unverified — never as proof of payment — see Verify the payment result. - Your return pages send
Referrer-Policy: no-referrer(or stricter) so redirect query params aren’t leaked to third-party resources. - Your production
success_url/cancel_urldomains are registered inallowed_domains. - For an
expiredsession withdecline_reason: "expired_while_processing", you treat the outcome as unknown and wait for thepayment.*webhook (de-duplicated on the eventid): you fulfil onpayment.captured(or void before settlement), and not on a decline, reversal, or failure. When the session’sgateway_transaction_idis set, you can also poll the transaction status every 60 seconds until it’s final, and you contact Support if nothing settles within 60 minutes ofexpires_at— see Session expired mid-payment. - Your error handling matches the whole Checkout API
typeURN (urn:radiumone:checkout-hpp:…) — there’s nocodefield to branch on. - You handle the failure scenarios in Handle hosted checkout failures.
Hosted checkout + RadiumOne 3D Secure
Hosted checkout + RadiumOne 3D Secure
- Everything under Hosted checkout, no 3D Secure above.
- You’ve requested enablement for RadiumOne 3D Secure on this outlet.
- You send the shopper’s
billing_detailson session create — at least the cardholder’s name and an email or phone number — see 3DS with hosted checkout. - Embedded mode only: every
https://page origin that embeds the checkout is on your allowed origins, in sandbox and production — see Allowed origins. Redirect mode needs none. - You handle a failed authentication like any other declined payment: there’s no separate 3D Secure status, redirect parameter, event or webhook.
Elements, no 3D Secure
Elements, no 3D Secure
- Install and load Elements using the npm
loader, or the version-pinned production CDN
<script>tag with itsintegrityhash — not the floating sandbox tag you tested with. - Accept a card payment works end-to-end in sandbox with approval and decline test cards.
- Your Content Security Policy matches Content Security Policy, rolled out report-only first before you enforce it.
- You handle
ElementsErrorfromsubmit()by showingcustomerMessageand checkingretryAllowed— never the rawmessage. Any branching oncodematches the whole URN, never a prefix. - You handle the failure scenarios in Handle Elements failures.
Elements + RadiumOne 3D Secure
Elements + RadiumOne 3D Secure
- 3DS with Elements works end-to-end in sandbox with frictionless, challenge, and not-authenticated test cards.
- Your
threeDS.authenticate()call passesselectedPaymentMethod(for example"card") — it’s required. - Your server independently verifies the
three_dsref at charge time and never branches on the client-reported status alone — see 3D Secure overview: server policy. - Challenge return pages send
Referrer-Policy: no-referrer, matching Challenge presentation and redirects. - Your CSP allows the 3DS challenge iframe/redirect hosts, including
your API origin in
connect-src, scoped to checkout/return routes only. - Every
https://page origin that runs 3D Secure is on your allowed origins — see Content Security Policy. - You’ve requested enablement for RadiumOne 3D Secure on this account before testing this row.
Payments API + your own 3D Secure provider (enabled per outlet)
Payments API + your own 3D Secure provider (enabled per outlet)
- You’ve requested enablement for your own 3DS results on this outlet and for card details on its terminals.
- Use your own 3DS provider works end-to-end in sandbox, including the case where your provider is unreachable.
- Your PCI DSS scope assessment covers the card details you collect and send, and your 3DS provider .
- Your server still independently verifies the evidence the gateway accepted — never trust your own provider’s client-side result alone.
High-risk operations
Only applies if you use standalone refunds.- The key used for standalone refunds is scoped to only that operation — not a general-purpose key.
- Secret keys live in a server-side secrets manager, never in client code, source control, or logs.
- Only the specific server-side service that needs it can call the standalone-refund endpoint.
- You monitor refund and settlement volume for anomalies and alert on unexpected spikes.
- You know who to contact for emergency key revocation if a key leaks .
- You’ve run a rotation drill — rotating a key end-to-end with no downtime — at least once before go-live.
Next steps
Test your integration
Run every scenario in this checklist first.
Security and PCI scope
Full key-safety and PCI guidance.
Frequently asked questions
Quick answers on keys, refunds, duplicates, and hosted checkout.