Partner integration

This is the most uncertain part of the project, and the only one we cannot settle on our own. This page sets out what we know, what we do not know yet, and the architecture that lets us start without waiting for the answer.

A shift of perspective

The Western Union, Ria and MoneyGram APIs are not designed for sub-agents. They address fintechs and banks wanting to embed money transfer into their own product — not a counter wanting its own operations back.

The real chain is this:

Network (Western Union, Ria…)
        ↓
Master agent / bank  ← this is where the network contract sits
        ↓
Sub-agent  ← this is where you are

You most likely have no direct contractual relationship with the network. You have one with a bank or master agent, who holds the contract.

The four access levels

One operations module, driven by a configuration record per partner. The level reached depends on what the partner grants, and it can change over the product's life through configuration.

The last two levels depend on no external authorisation. Your principal agent already sends you a daily statement: that is the raw material for import. Version 1 is fully functional with those two levels alone, for all six partners — which is what lets the project reach completion without depending on a third party's calendar.

What is configurable, and what is not

The phrase "adding a partner means filling in a form" is true in one case out of two. Here is the exact distinction.

The scope frozen at framing states, partner by partner, which of these three situations each falls into, based on the information available at that time.

Read or write: the distinction that changes everything

Do not ask for “an API”. Ask which one — there are two natures, and they commit you to very different things.

A read API hands back your own operations. Reading your own data is not a regulated activity: no exposure, no new liability.

A write API creates the transfer. AiO then stops recording what happened elsewhere: it makes it happen. Three things shift.

Regulatory status. In the CEMAC zone, the reform under way explicitly creates a category of payment service operators covering payment initiation, subject to approval by the national monetary authority after COBAC opinion. If AiO initiates transactions, the question “who is the licensed operator” arises immediately. It does not arise at all while AiO merely records.

Liability. Today, if the partner terminal fails, that is the partner's problem. If AiO initiates and fails midway, it is ours — and yours. Cash out of the till with no reference issued is real money to be found.

The technical difficulty changes order of magnitude. The concrete problem:

AiO calls the API. The network drops. Did the operation go through or not?

It went through and you retry → double transfer, money genuinely lost. It did not and you do not retry → the customer paid, nothing was sent.

You cannot guess. You need an idempotency key accepted by the partner, a status query endpoint, and a reconciliation loop that settles the uncertain cases. This is the hardest part of payments engineering — and it does not exist at all in read-only mode.

Where each partner stands

The state of each partner programme, to the best of our knowledge today. To be confirmed contract in hand.

What an API partnership application requires

If the API route is pursued, here is what will be asked — and it explains why it is rarely within reach of a counter:

• Registered legal entity, with articles and accounts
• Regulatory status: licensed payment institution, or partnership with a licensed one
• Written AML/CFT programme and a named compliance officer
• Due diligence pack: beneficial owners, governance, insurance
• Volume commitments — this is a commercial partnership, not a subscription
• Technical certification: sandbox → certification → production

Realistic timeline: 3 to 9 months, dominated by legal and compliance, not by engineering.

The sequence we recommend

1. Ask the master agent for the statements. No cost, a few days, solves most of the need.

2. Re-read every agency contract. What it permits regarding exports and third-party processing is written there — and so are the clauses barring scraping.

3. Start the API applications in parallel, without depending on them. If they succeed, we add a connector — a short job, since the module is already in place.

This is exactly why the architecture provides four levels. The project must never wait for an API. It starts on statements, and any access obtained later is a gain, not a condition.

Where exceptions end up

An imported statement is not a reconciled statement. Whatever does not match lands in the same place: the exception queue. It is the screen nobody designs and everybody uses — the branch manager's screen at 6 p.m., when the count does not come out right.

Select a row: the three reconciliation sources appear, and the diverging one is highlighted. That is the whole job of the system — saying not "there is a discrepancy" but "here is which of the three sources disagrees with the other two".

What we commit to

On a subject half of which is outside our control, the commitment must be precise. Here it is, as it appears in the dossier.

1. Deliver the module and its exception queue for all six partners, on statement import and assisted entry.
2. Supply the access request pack for each operator — recipient, exact name of the access, documents required — so your agency can start the process without delay.
3. Connect one API whose access is opened and documented before the end of month 6, provided its protocol falls into the first two situations above. Included in the price.
4. Quote separately for further connections, or those opened after month 6. With the module already in place, those connections are short.

In version 1, no real-time connection is promised: an agent starting out does not obtain API access in the first year, and an access opened mid-project could not be built, certified by the network and accepted within six months. The connection therefore belongs to phase 3, triggered when a network opens one to you. Writing it into V1 would be promising a calendar that neither you nor we control.