Five API flaws that put African mobile money platforms at risk
A field guide to the authorisation, transaction and integration weaknesses that can turn a routine mobile money API into a route for fraud.

In this article
Why mobile money APIs need adversarial testing
Mobile money platforms connect customer apps, agent networks, banks, merchants and payment processors. The API is the shared language between those systems, which makes it both essential infrastructure and a high-value target. A weakness that looks minor in isolation can become serious when it affects thousands of wallets or an automated settlement process.
Conventional vulnerability scanning is useful for finding known software issues, but it cannot determine whether a legitimate API request should be allowed. That requires testing the business logic: who owns a wallet, which role can approve a transfer, when a transaction expires and what happens when the same instruction arrives twice. The five weakness patterns below are a practical starting point for that work.
Replayable and duplicate transactions
A transfer request should represent one intentional action. Without a unique transaction identifier and server-side duplicate handling, the same valid request may be processed more than once. Delays, retries and unstable connections make this especially important: a safety mechanism intended to improve reliability must not accidentally debit a customer twice.
Replay testing should cover more than pressing send twice. Test delayed requests, concurrent requests, modified timestamps and retries across different app sessions. Review how the platform behaves when a response is lost but the transaction succeeded, and ensure that a customer can safely reconcile the outcome without creating another payment.
- Require a unique idempotency key for each financial instruction.
- Store and enforce that key at the service that commits the transaction.
- Give requests a short validity window and protect their integrity with appropriate signing.
- Return the original result for a legitimate retry rather than executing the payment again.
Security controls that exist only in the app
Mobile apps can guide users and reduce mistakes, but they cannot be the final authority on security. An attacker can inspect a released app, call its API directly or modify the values it sends. Limits on transfer amounts, agent permissions, PIN attempts and transaction frequency must therefore be enforced by the server.
Test the API without the restrictions imposed by the interface. Submit values the app hides, skip screens, repeat actions and call endpoints out of sequence. A transfer that should require approval, for example, must not succeed simply because the approval step was bypassed in the client.
- Recalculate limits, fees and eligible transaction types on the server.
- Bind sensitive actions to a verified session and a clear step-up authentication event.
- Keep a server-side record of transaction state rather than trusting a client-supplied status.
- Assume every public app binary and its API documentation can be examined by an attacker.
Excessive trust in partners and webhooks
Banks, aggregators, merchants and service providers often receive privileged access so transactions can move without friction. Over time, temporary credentials, broad permissions and unrotated secrets can turn those connections into a bypass around otherwise strong customer controls.
Webhook handling deserves the same scrutiny. If a payment notification is not authenticated, an attacker may be able to mark an order as paid or trigger a fulfilment process. If it is authenticated but not protected against replay, a genuine old notification may still be reused.
- Give each integration its own identity with only the permissions it needs.
- Authenticate webhook messages, validate timestamps and reject duplicates.
- Restrict network access where practical and monitor for unusual partner behaviour.
- Test credential revocation, rotation and offboarding as carefully as onboarding.
Useful controls undermined by enumeration
Predictable references, detailed error messages and unlimited requests can help an attacker discover valid accounts or transaction records. Even when no direct transfer is possible, confirming whether a phone number holds an account can expose customers to targeted phishing and social engineering.
Rate limits should reflect behaviour across an account, device, network and integration rather than relying on a single IP address. Responses should avoid revealing unnecessary account details, while internal logs should retain enough context for fraud and security teams to distinguish customer mistakes from systematic probing.
A practical testing and remediation roadmap
Begin with the journeys that move money or change account control: registration, login, PIN reset, transfers, cash-out, reversals and partner settlement. Map the roles and objects involved, then build tests around the actions each role must never be able to perform. Include the API gateway, application services and operational dashboards in that map.
Prioritise fixes by realistic financial and customer impact, not by a scanner score alone. After remediation, replay the original attack and add a regression test so the same flaw does not return during a routine release. For platforms that change frequently, focused testing after high-risk changes can complement a broader annual assessment.
- Week one: map critical journeys, roles, objects and trust boundaries.
- Week two: test authorisation, replay, workflow and integration abuse with production-like data.
- Week three: validate fixes and agree monitoring for attempted exploitation.
- Ongoing: retest high-risk changes and preserve evidence of remediation.
