Bankit: reading a Nigerian wallet ledger over the NIP rail

Every naira that leaves a Bankit account clears over NIBSS Instant Payment, the real-time interbank rail that moves most electronic transfers in Nigeria. That single fact shapes the integration. The data worth reading is a live stream of NIP legs — each one carrying a unique session id, a counterparty, an amount in kobo and a channel — layered over the bill, airtime, savings and loan records the app keeps against a customer's wallet. Bankit MFB is a CBN-licensed microfinance bank run out of Lekki, Lagos, and, by its own account and Nigeria's deposit-insurance listing, NDIC-insured. What it holds for one account is exactly what a lender, a bookkeeping tool or a money-management app would want to pull.

The bottom line is short. Bankit holds a clean, structured ledger per customer; the route that gets you all of it quickly today is authorized interface integration of the app's own session, with the CBN open-banking channel wired in as Nigeria's registry rollout firms up. We build the worker, normalize the records, and hand you code that runs.

What sits behind a Bankit login

These are the surfaces the app shows an account holder, mapped to what an integrator would do with each. Field names below come from how the app presents them, not from any published Bankit document.

Three ways into the ledger

Three routes apply here. They differ in how much they reach, how long they last, and what we set up to run them.

Authorized interface integration

We analyse the app's own authenticated traffic, under your authorization and the account holder's, and rebuild the calls as a clean client. This reaches everything the app shows the customer: the full ledger, bills, savings, loans. Effort is moderate; durability tracks Bankit's releases, which is why we re-validate the captures whenever the app version moves. This is the route we would run as the working spine, because it gives complete coverage now without waiting on anything.

CBN open-banking consent

Once Bankit is listed as an API provider in the NIBSS registry, a consented pull through the open-banking channel returns the data categories the customer grants, validated by an encrypted token on every call. Durability is high — it is the regulated path — and the effort is in the consent handshake and token handling, which we wire. Nigeria's go-live has been phased, so we treat this as the durable destination and lean on consent today.

Consented credential access and native export

Where a customer prefers to hand over access directly, or the app offers an in-app statement, we read what that gives. Low effort, lowest durability; useful as a backfill or a fallback rather than the backbone.

For most teams the practical build is the first route now, with the registry path layered in as it stabilises. We arrange the access and consent records with you during onboarding; that setup is our work, not a hoop you clear first.

What the calls look like

A sketch of the worker against the wallet ledger. It is illustrative — the exact paths and field names are confirmed during the build against captured responses, not lifted from a Bankit spec.

# Illustrative: pull a Bankit wallet ledger as a replayable stream.
# Cursor = last NIP session id seen; None on the first backfill.

def pull_ledger(session, consent_token, cursor=None):
    r = session.get(
        "https://api.bankitafrica.com/v1/wallet/transactions",
        params={"after": cursor, "limit": 200},
        headers={"Authorization": f"Bearer {consent_token}"},
    )
    r.raise_for_status()
    body = r.json()

    for tx in body["items"]:
        yield {
            "ref":         tx["sessionId"],          # NIBSS NIP session id, globally unique
            "direction":   tx["type"],               # "credit" | "debit"
            "amount_kobo": tx["amount"],              # minor units (100 kobo = ₦1)
            "channel":     tx["channel"],             # "transfer" | "bill" | "airtime" | "save"
            "party":       tx["beneficiary"]["accountName"],
            "state":       tx["status"],              # "pending" | "completed" | "reversed"
            "booked_at":   tx["completedAt"],
        }
    return body.get("nextCursor")      # checkpoint for the next wake-up
      

The worker drops each record onto a queue keyed on the session id. Because every NIP leg id is unique, a replayed backfill lands on the same keys and the warehouse keeps one row per transaction. A pending leg that later reverses is re-emitted with its final state, so the ledger settles on the truth rather than the optimistic first read.

What lands in your repository

The work ships as code first, documents alongside it.

• Runnable clients in Python and Node.js for the ledger pull, name enquiry and transaction-status query.
• A queue worker with cursor checkpointing and replay, so a cold start backfills and a warm start tails.
• A webhook handler stub for transfer-completed and bill-paid notifications, where that surface is available.
• An automated test suite built from captured fixtures, with contract tests over the normalized records.
• A normalized transaction schema: kobo minor units, session-id keys, a pending/completed/reversed lifecycle.
• An OpenAPI description of the rebuilt surface, plus an auth-flow report covering the token and session chain.
• Interface documentation and data-retention guidance for keeping consent and access records.

Consent and the CBN rulebook

The governing frame is the Central Bank of Nigeria's Operational Guidelines for Open Banking, finalised by circular in March 2023, with the central registry operated by NIBSS and consent anchored on a customer's BVN. The guidelines sort data into categories of rising sensitivity, from public product information up to consented personal and transaction data, and require an encrypted consent token that the provider validates on each call. The Nigeria Data Protection Act sits over the personal data itself. The rollout has run in phases through 2026 and is still settling, so we do not treat any single registry obligation as fixed present-tense plumbing; the reliable basis we build on is the account holder's explicit authorization, with the registry route fitted in as it matures. Access is logged, data is kept to what the use case needs, and we sign an NDA where the work touches anything sensitive.

Wrinkles we plan around

Two things about Bankit specifically shape the build, and we account for both rather than push them onto you.

Money is in kobo, and NIP legs can change state

Amounts come through in kobo, so we normalize to a consistent minor-unit field and keep currency explicit, no floats. NIP transfers can sit pending, complete, or reverse after the fact; we model that lifecycle so a downstream ledger reflects the final outcome instead of the first hopeful write.

Consent windows and counterparty names

A consent token has a life, so we design the sync to re-authorize within that window instead of letting the feed quietly lapse. Counterparty names are not always carried inline on a transfer, so we resolve them through NIP name enquiry against the account number and cache the result, which keeps statements readable.

Cost and cadence

Source delivery starts at $300 and you pay after we hand it over, once the code runs to your satisfaction; that buys the runnable client, the worker, tests and documentation for your Bankit integration. If you would rather not host anything, the second option is our pay-per-call hosted API — you call our endpoints, you are billed only for the calls you make, and there is no upfront fee. A first delivery runs one to two weeks. Tell us the data you want out of Bankit and we take it from there: start a project on the contact page.

Where teams wire this in

• A lender reading a consenting customer's Bankit transfer and bill history to judge affordability before disbursing.
• An SME bookkeeping tool folding Bankit wallet movements and bill payments into its ledgers automatically.
• A personal-finance app aggregating a user's Bankit balance next to their other Nigerian wallets in one view.
• A disbursement platform confirming a payout landed by matching the NIP session id through transaction-status query.

Screens we mapped against

The app's store screenshots, which we used to read the visible surfaces. Select one to enlarge.

What we checked

We read Bankit's own site and Nigerian press coverage for the app's feature set and licensing, then cross-read the Central Bank of Nigeria open-banking guidelines and the NIBSS instant-payment documentation for the route and the rail. Sources reviewed in June 2026:

• CBN Operational Guidelines for Open Banking in Nigeria (PDF)
• NIBSS Instant Payment (NIP) overview
• Nigeria open banking: data access considerations
• Bankit Africa — product site

Notes compiled by OpenFinance Lab's integration engineering team — 2026-06-14.

Neighbouring Nigerian wallets

Bankit sits in a crowded field of Nigerian wallets and digital banks. A team building a unified view usually reads several of these together, since they share the same NIP rail and BVN identity layer.

• OPay — high-volume wallet with transfers, bills and a large agent network; a heavy source of NIP traffic.
• PalmPay — payments wallet with savings and cashback on bills and airtime.
• Moniepoint — banking and collections built around business accounts, transfers and bill payments.
• Kuda — digital bank with transfers, savings, cards, loans and budgeting tools.
• Paga — one of the older wallets, covering transfers, bills and merchant payments.
• FairMoney — lending-led app that also runs accounts and bill payments.
• Carbon — credit-first wallet with loans, transfers and bill payments.
• PiggyVest — savings and investment app holding goal balances and payout records.

Questions integrators ask

How fresh is the transaction data you sync from Bankit?

As fresh as the route allows. Each NIP leg carries a unique session id, so we run a worker that keeps a cursor on the last session it saw and replays the gap on every wake-up. With a webhook surface in play it is near-immediate; on a poll it is a short interval. A re-run lands on the same session keys, so the warehouse keeps one row per transaction rather than duplicating the backfill.

Bankit settles over NIBSS — what does that mean for matching transfers?

NIP gives every leg a globally unique session id and exposes name-enquiry and transaction-status-query calls. We key the ledger on that session id, resolve counterparty names through name enquiry, and model a status lifecycle of pending, completed and reversed so a transfer that later bounces is corrected instead of left optimistic.

Which regulator and consent model covers reading a customer's Bankit data?

The Central Bank of Nigeria's open-banking guidelines, with the registry run by NIBSS and consent anchored on the customer's BVN. Bankit is a CBN-licensed microfinance bank. The Nigeria Data Protection Act sits over the personal data. The framework's go-live has been phased through 2026 and is still bedding in, so the dependable basis we build on is the account holder's own authorization; the registry route is wired in as it matures.

Can you cover Bankit savings, cashback and loan balances, not only transfers?

Yes. The same authenticated session that exposes the wallet ledger also carries the savings position, the cashback or rewards accrual the app shows, and any in-app loan with its balance, schedule and status. We map each as its own normalized record so a downstream tool can read a single account's full position, not just its send-money history.