Talk to us

PaySim simulator

Rehearse before go-live.

PaySim simulator plays the payment scheme and the other banks inside your own environment. Your teams can build integrations, rehearse payment flows and test how their systems handle failures, using synthetic data away from live networks.

Your bank sends a test payment into PaySim, a miniature copy of the Aani, RTGS and SWIFT networks and the other banks. The road to the live networks stays closed until your bank is ready.

A flight simulator for payments.

Pilots practise in a simulator before they fly. PaySim gives your bank the same kind of rehearsal space. It plays the payment networks and the other banks inside your own environment, so your teams can send, receive, delay and return payments using made-up data and test keys. Nothing you rehearse can reach a real account or a real customer.

Choose your rails.

PaySim covers Aani instant payments, RTGS high-value payments and SWIFT cross-border payments using ISO 20022 CBPR+. Each rail is its own module, so you load only the rails you use and choose which organisations and people can work with each one. Focus mode keeps payments, ledgers and statements on the rail your team is working on.

Follow a SWIFT payment.

A cross-border payment can pass through several banks before it arrives. PaySim lets you follow it like a parcel, stop by stop, using one tracking reference. You see the delays, fees and outcome at each stop, then the answers that come back to your bank: accepted or declined, money sent back, a recall and its reply, and the statements. All of this happens before you connect to the real network.

Practise the difficult days.

Most testing covers the good days. With PaySim you can also run drills for Aani and RTGS. Switch on a simple rule and a payment is declined with a reason, gets no answer in time, is paid and then sent back, or is answered slowly. Rules look at the amount, the account or the reference, with no code needed. Ready-made drills cover the common outcomes, and each team can add its own.

Ready for rush hour.

Before go-live, send thousands of Aani instant payments through the same channels you will use in production: message queues, online API calls and file transfer. PaySim replies to every payment, times each reply and can slow down on purpose, so you see which replies go over the limit on each channel.

Rehearse your security.

On go-live day, every connection needs the right keys, certificates and checks. PaySim lets you practise each step with test keys first: get your certificates, have both sides prove who they are, sign and seal messages, check the seal and change keys without a break. For Aani, you exercise your bank's own side of the connection, using TLS, your certificates, message signing and encryption. For SWIFT, message signing and secure access are simulated with test keys.

Performance and connection rehearsals apply to Aani. For SWIFT, PaySim simulates messaging and counterparties, not Swift's own infrastructure or PKI. PaySim never asks for production credentials.

Check every message.

PaySim works like a spell-checker for payment messages. Every message your systems send is checked in layers: is it readable, does it follow the standard's layout, does it meet the network's rules, do the details agree, and does it pass your own rules? Each finding tells you which rule applies, exactly where, how serious it is and how to fix it. Checks are pinned to the version of the standard you build against, so results stay the same from one run to the next.

Balance the books.

PaySim keeps the books for every test account, much like balancing a chequebook. It keeps a running balance, respects cut-off times and holidays, and sends the reports your team reconciles: a notice after each payment, updates during the day and a statement at the end of the day. Your team can then check that the opening balance plus every movement equals the closing balance, with nothing missing.

Replay with proof.

Pick a test, reset the clock and run it, from the portal or automatically in your build pipeline. The same test gives the same result every time, and every run leaves a report: what was sent and received, each step in order, expected against actual, the time per step and which test version ran. Keep it as evidence for your release sign-off.

Connect your systems.

PaySim works with CordisPay and with your existing payment systems. AMQP 1.0 and REST provide the same interfaces across rails, using ISO 20022 in the versions each scheme uses. Developers, testers and operations teams can work in the same environment, with separate workspaces and permissions.

PaySim is independent of scheme operators, including Swift. It does not replace official testing or certification, or simulate Swift’s own infrastructure or PKI.

The details.

Message flows, failure cases and controls for your technical teams.

Aani flows and security
  • Credit transfersSend and receive payments with status reports and status requests (pacs.008, pacs.002, pacs.028).
  • Returns and reversalsReturn or reverse a payment and follow both sides (pacs.004, pacs.007).
  • Account verificationHold settlement until the receiving bank confirms the account, then accept or reject.
  • Liquidity transfersMove funds between institutions (pacs.009).
  • Statements and reconciliationIntraday and end-of-day statements (camt.052, camt.053) with three-way matching and injected differences.
  • Message securitySigned and encrypted messages, so security handling is tested too.
  • Performance testing (Aani)Run high volumes against your own systems before go-live to see how they behave under load.
  • Connectivity and security rehearsal (Aani)Exercise your bank’s TLS connections, certificates, message signing and encryption before production.
SWIFT CBPR+ flows
  • Customer paymentsCross-border credit transfers tracked end to end by their unique reference (UETR) (pacs.008).
  • Bank and cover paymentsPayments between banks, including cover payments (pacs.009).
  • Status and returnsStatus reports and returns (pacs.002, pacs.004), with network acknowledgements kept apart from the business outcome.
  • RecallsRequest and answer a recall (camt.056, camt.029). Money comes back only through a return.
  • Correspondent chainsPayments that pass through up to two intermediary banks, with balances per correspondent and currency, and charges paid by the sender, the receiver or shared.
  • Account reportsIntraday and end-of-day statements and booking notices (camt.052, camt.053, camt.054).
  • Cut-offs and value datesCut-off times per currency, with weekends and holidays moving the value date.
Failure scenarios
  • Rejections with scheme reason codes, such as unknown account, closed account, amount over the limit and duplicate payment
  • Timeouts and slow responses, with latency you control
  • Server errors and dropped connections
  • Automatic returns after settlement
  • Settlement limits, so a bank cannot pay beyond its balance
  • SWIFT reject reasons, recalls that are refused and payments that stall at an intermediary bank
  • Fees deducted along the chain
  • Missing, duplicate and out-of-order responses
Rail controls
  • For each deploymentLoad only the rails you use. A rail that is off adds no screens, queues or interfaces.
  • For each organisationChoose which rails each organisation can use.
  • For each personLet each person view, send or configure each rail.
  • Focus modeWork on one rail at a time. Payments, ledgers and statements show only that rail.
Workbench
  • Live payment streamWatch payments and their status as they move.
  • Settlement ledgerSee balances and every posting behind them.
  • SearchFind any payment by reference and follow its history.
  • Teams and workspacesSeparate workspaces for each organisation, with rail permissions for each person.
Repeatable tests
  • Virtual clockPause, move forward or speed up time to test cut-offs and delays.
  • Scenario libraryReady-made scenarios with the expected messages and final state, and a record of every run as evidence.
  • Inbound testingReceive payments, cover payments and recalls from the simulated other side. Replay presets, including Arabic payment details, and check response times.
For your team
  • DevelopersBuild against realistic scheme behaviour from day one.
  • TestersRepeatable scenarios, including the failure cases.
  • OperationsRehearse incidents and returns before they happen for real.
  • Implementation partnersA shared test environment for every project.

Common questions

Can we test without connecting to the live scheme?

Yes. PaySim simulator runs in your own environment with synthetic data. It simulates scheme messaging and the other banks without touching live networks.

Can we run Aani negative and performance tests?

Yes. Exercise rejects, timeouts, missing, duplicate and out-of-order responses, returns and stalled payments. Aani performance testing runs high volumes against your own systems before go-live.

Does PaySim simulate Swift’s own infrastructure or PKI?

No. PaySim simulates network messaging and counterparties for SWIFT CBPR+, not Swift’s own infrastructure or PKI. It does not replace official certification or the operators’ own test services.

Can PaySim work with our existing payment systems?

Yes. PaySim simulator works with CordisPay and with your existing payment systems. AMQP 1.0 and REST are the same for every rail, using ISO 20022 in the versions each scheme uses.

More about PaySim

Rehearse with your team.

Tell us which rail and flows you want to test.