Real-Time Gross Settlement (RTGS): How It Works and Why It Matters
Try Formance Ledger
Clone the Formance Ledger on GitHub, run it locally, and post the two-step wire as your first transaction.
Try Formance Ledger
Clone the Formance Ledger on GitHub, run it locally, and post the two-step wire as your first transaction.
Real-time gross settlement (RTGS) underpins Fedwire, the Clearing House Automated Payment System (CHAPS), and T2. These three payment rails settle each payment individually and in full, with legal finality attaching the instant the rail credits the receiving participant or notifies them. A core ledger must post around that finality event, because once a wire is final, the rail will not reverse it.
When an outbound wire times out at the sponsor bank's application programming interface (API), the retry returns HTTP 200 OK. The next morning, the bank statement shows one outbound line for $2.5 million, but your core ledger shows two postings. Both are marked "sent" because the ledger marks a wire sent the instant the API call returns.
Finance spends the close chasing a phantom posting no bank line explains, and every balance built on it is off by $2.5 million. If the retry had been submitted as a second instruction, the rail would have settled it, and recovery would have to be resolved bilaterally with the receiving party.
That $2.5 million failure happens because RTGS does not forgive imprecise ledger integrations. Wires are final the instant the rail settles them, with no net or batch window to absorb a duplicate, and no clearinghouse will reverse the second instruction.
Learn how RTGS works across the three major rails, why finality reshapes ledger design, and how to post wires with the two-posting pattern that prevents duplicates.
RTGS settles each eligible, funded payment individually and at full value, with no deferral and no netting. "Real-time" means the system does not hold the instruction for a processing cycle. "Gross" means the full face value moves, and no payment is offset against payments flowing the other way.
There are three major RTGS systems a modern platform integrates:
RTGS differs from deferred net settlement, the model your ACH integration already assumes, because it removes both the netting and the batch window. Each payment settles individually, so a batch-level reject cannot arrive hours later after your customer believes the money moved. The receiving bank can still return an individual wire for sanctions screening or an unknown beneficiary.
For a payment-processing team, the combination of individual, full-value settlement with no netting sets four hard constraints:
Design the ledger and the submission path around these four constraints, or the rail will expose the gap on the first duplicate.
Real-time gross settlement moves each wire through four rail-side states your integration should treat as four distinct events. These are submission and validation, queueing and gridlock resolution, settlement and finality, and confirmation and messaging.
Formance Ledger is our open-source, programmable core ledger that gives you the primitives (immutable postings, metadata, and bi-temporality) to model the four wire states across fiat and digital assets with regulatory-grade traceability.
Admit a payment once it passes the rail's technical submission and validation checks.
Acceptance means sponsor or rail admission, not settlement eligibility, so an accepted instruction may still queue if funds or credit are unavailable. Acceptance is the first event your core ledger should record.
Before admission, the instruction has no standing on the rail, and a malformed message or an account that fails a check gets rejected with no funds moved and no ledger entry written.
If you are not a direct participant, your integration submits through a sponsor bank, and you may see the sponsor's acceptance first, then the rail's acceptance. Model both as the same ledger event, keyed on your instruction ID.
Queueing holds a validated payment that lacks cover until an incoming credit funds it or the window closes.
Gridlock resolution runs optimization routines that settle offsetting queued payments together when no single payment can clear on its own.
Queued is a third state that a schema with only "sent" and "settled" cannot represent. Queue resolution is event-driven, so your instruction can settle at any moment after acceptance without any action from you.
Model queued as a status on the funds-in-flight balance.
Settlement makes an RTGS payment final and irrevocable at the earlier of two events: credit to the receiving participant's account, or notice to that participant.
Finality can attach on notice before the credit lands, and once it attaches, the rail will not revoke the instruction.
This is standard RTGS behavior under the Bank for International Settlements' (BIS) Principles for Financial Market Infrastructures. Specifically, Principle 8 mandates that an FMI “should provide clear and certain final settlement”, requiring the rail's rules to define a finality point and prohibit revocation after it. Settled transactions “will not be voided [or] reversed”.
For ledger purposes, rely on the sender-side settlement confirmation available through your integration, including any relay from a sponsor bank, and clear the funds-in-flight balance only on that confirmation.
Confirmation and messaging close each wire with a settlement message, and all three major rails now carry those messages in ISO 20022.
ISO 20022 carries end-to-end IDs and transaction references in dedicated fields rather than free text. Posting two can key cleanly on the message's stable transaction identifier.
Normalize the three rails into one shape when you ingest, and ensure the idempotency key for the settlement posting is the same field across Fedwire, CHAPS, and T2.
RTGS sits at the top of the integration backlog of engineering and treasury leads at fintech platforms, PSPs, and corporate treasuries that move high-value or time-critical flows.
Unlike ACH or card rails, where a batch window, netting cycle, or chargeback mechanism can absorb an error, RTGS removes all those safety nets and reshapes the ledger design around three constraints.
Irrevocable transaction finality forces you to resolve an erroneous wire bilaterally with the receiving party rather than recall it through the rail, and recovery can take years.
Once the rail delivers final settlement, there is no mechanism to claw back the funds. You must negotiate directly with the recipient, and if they refuse, the dispute moves into litigation that can run for years before any funds are returned.
Recovery hinges on proving what was sent and when, therefore, the core ledger must show what was sent, when, under which instruction identifier (ID), and against which confirmation.
Wholesale rails move trillions in central-bank money every day, so a single lost acknowledgment at a multi-million-dollar average wire size is a multi-million-dollar exposure from one duplicate wire.
The $2.5 million scenario is the same failure mode: a timed-out API call, a retry treated as a new instruction, and a second wire the rail settles with the same finality as the first.
Duplicates are especially costly because detection is bilateral too, and you only learn about the second posting when the bank statement arrives the next morning. By then, recovery runs on the same multi-year timeline as any other erroneous wire.
If you participate directly as a non-bank payment service provider eligible to hold a central-bank RTGS settlement account, you also design to fund your own cover and run your own reconciliation, which raises the stakes further.
Liquidity discipline is an engineering concern because gross settlement requires a funded position for every payment throughout the operating window, removing credit risk at the cost of more liquidity.
A payment with no cover waits in the queue, and a missed cover or a stuck queue is a business-day event. Operations learns at 3 p.m. that a $2.5 million payment has been queued since 11 a.m., while the customer's balance already shows the $2.5 million gone.
Surface the queued state in your core ledger and size intraday funding per rail from your own outbound profile.
Posting an RTGS wire in a core ledger comes down to four components: a per-rail in-flight account, an acceptance posting, a settlement posting, and outage handling.
Each rail needs an in-flight account that holds funds between acceptance and settlement, with a status metadata field to flag queued payments.
Use one per rail (one for Fedwire, one for CHAPS, one for T2) and pair each with a named external account for settled wires.
The customer's balance sits inside an omnibus account at your sponsor bank, so the customer's claim runs against the ledger posting rather than the bank balance.
Use a named external account instead of a generic @world sink, because the transaction reconciliation in the outage-handling step needs one account that reconciles one-to-one with the rail's statement lines.
Posting one fires when the sponsor bank or rail accepts the instruction, and the posting carries an instruction ID you generated before submission.
The example below is written in Numscript, Formance's purpose-built transactional language, which describes transaction intent in terms readable by both engineers and finance teams.
The account shape works in any double-entry ledger, so you can translate it to whatever posting language your stack uses.
For a $2,500,000.00 outbound wire:
// RTGS_WIRE_ACCEPTANCE
// Event: accept wire wire001 and move $2,500,000.00 into Fedwire pending
send [USD/2 250000000] (
source = @users:4821:available
destination = @platform:rtgs:fedwire:out:pending
)
set_tx_meta("event_type", "rtgs_wire_acceptance")
set_tx_meta("wire_id", "wire001")
The instruction ID should be the idempotency key for the ledger posting, with deduplication enforced in your integration before any write to the ledger. The timed-out retry from the opening scenario carries the same ID, so the integration returns the existing posting instead of writing a second one.
One key travels with the payment through every system it touches, linking the request from your app, the posting, the call to the sponsor bank, and the message the sponsor puts on the rail.
Posting two clears the in-flight account when your settlement confirmation arrives, and the posting's idempotency key should be derived from a stable, immutable settlement event identifier.
Trigger posting two only when your own settlement confirmation arrives, relayed by the sponsor bank. Elapsed time and the sponsor's acceptance alone are not triggers.
// RTGS_WIRE_SETTLEMENT
// Event: settle wire wire001 after confirmation stl001
send [USD/2 250000000] (
source = @platform:rtgs:fedwire:out:pending
destination = @external:fedwire:out:settled
)
set_tx_meta("event_type", "rtgs_wire_settlement")
set_tx_meta("settlement_message_id", "stl001")
A reject or a cut-off miss gets a compensating posting from @platform:rtgs:fedwire:out:pending back to @users:4821:available. The compensating posting's idempotency reference is the reject message ID.
Never delete the acceptance posting because immutability shows an auditor that the wire was attempted and then refunded.
Rail-outage handling relies on bi-temporality to record late confirmations truthfully and on reconciliation to catch stuck in-flight balances before they drift into exceptions.
On 27 February 2025, the European Central Bank's (ECB's) T2 system suffered a roughly 8- to 10-hour outage that delayed interbank payments.
A platform running the two-posting model during that window would have seen in-flight balances hold their state until the rail resumed and confirmations flowed through.
An unconfirmed payment stays in the in-flight account; a timeout never triggers an automatic reversal. A delayed instruction could settle after a platform-side timeout had expired, and a ledger that reversed on timeout would then show the in-flight funds back in customer balances.
Ledger bi-temporality tracks both when an event was recorded and when it became effective, so you can truthfully record a late confirmation. When the confirmation arrives at 4:40 p.m., post it at 4:40 p.m. with an effective time of when the rail settled the wire.
Reconcile each statement line one-to-one against @external:fedwire:out:settled on transaction ID and amount, with the posting date as a separate check.
Any balance left in @platform:rtgs:fedwire:out:pending after the reconciliation window is an exception.
Run these five checks before the first production wire leaves. Each one closes a failure mode the rail will expose while funds move.
With the two postings in place, you no longer maintain the hand-rolled in-flight state table.
A programmable, double-entry ledger carries the weight of the precision RTGS demands. It keeps acceptance and settlement as separate immutable events, enforces idempotency at the posting layer, and gives reconciliation a one-to-one target against the rail's statement lines.