Developers

Build financial products on FadPay

Accounts, transfers, atomic bulk payouts, payment-network telemetry and customer-authorized verification — one clean REST API on Africa's financial platform, in the language you already use.

Get API keys Read the reference

endpoints, one base URL

120/min

rate limit, honest headers

99.98%

API uptime

transfer.sh

# Move money to any FadPay Account by email
curl -X POST https://fadpaymoney.com/api/v1/transfers \
  -H "Authorization: Bearer sk_live_9f2c…" \
  -d '{ "to_email": "a.ndiaye@teranga.digital",
        "amount": 25000, "note": "Invoice #A-2291" }'

# → 201 Created
{ "ok": true, "to": "a.ndiaye@teranga.digital",
  "amount": 25000, "balance": 7975000 }

Built for builders

Everything you need to move money in code

A REST API that behaves the way you expect — predictable resources, honest errors and the guardrails that keep every franc safe.

Bearer-token auth

One Authorization header on every request. No sessions, no cookies, no handshake dance.

Test & live keys

Build fearlessly against the sandbox with sk_test_ keys, then flip to sk_live_ when you are ready — and rotate either in one click.

Atomic bulk payouts

Pay up to 200 people in a single POST. The batch settles all-or-nothing — no half-paid payroll, ever.

Signed webhooks

Real-time callbacks for transfers, payouts, collections and payroll — every delivery signed with your whsec_ secret.

Privacy by design

The API answers with attribute statuses, never raw documents — and the FadPay Score is not exposed at all.

Described in OpenAPI

The whole surface ships as machine-readable OpenAPI 3 — generate clients, mocks and tests from one JSON file.

API reference

The /api/v1 surface, end to end

Authenticate with a Bearer token, then read your account, watch the payment network and move money. Every response is JSON; every batch is atomic.

GET /api/v1/ping

Health check — confirm the API is up. No auth required.

GET /api/v1/openapi.json

Machine-readable OpenAPI 3 description of every endpoint.

GET /api/v1/account

The key owner's FadPay Account — balance, currency, holder.

GET /api/v1/transactions

Recent ledger entries with references, network and status.

GET /api/v1/network

Payment-network status — rail health, success rate, latency.

GET /api/v1/identity

Your verified attribute statuses — never raw documents or data.

GET /api/v1/payroll/runs

Payroll history with totals and references. Company keys only.

POST /api/v1/transfers

Send money to any FadPay Account by email — instant settlement.

POST /api/v1/payouts

Bulk payout, atomic and all-or-nothing. Up to 200 items per batch.

POST /api/v1/qr

Create a payment handle and QR payload, with an optional amount.

GET /score returns 403 — on purpose

The FadPay Score is visible only to its owner: privacy by design. To verify a customer, request their authorization and receive an attribute answer — "Eligible", "Verified" — instead of the number.

Rate limits you can plan around

120 requests per minute per key. Every authenticated response carries X-RateLimit-Limit and X-RateLimit-Window headers, so your client always knows where the ceiling is.

The whole surface is machine-readable — GET /api/v1/openapi.json

Examples

Two calls, three languages

Read an account, then send a transfer — in curl, JavaScript and PHP. Amounts are whole integers of XOF; the API formats them for display when you want it to.

GET /api/v1/account — read the key owner's FadPay Account

account.sh

curl https://fadpaymoney.com/api/v1/account \
  -H "Authorization: Bearer sk_test_9f2c…"

# → 200 OK
{ "object": "account",
  "currency": "XOF",
  "balance": 8100000,
  "formatted": "8 100 000 F CFA" }

account.js

const res = await fetch(
  'https://fadpaymoney.com/api/v1/account',
  { headers: { Authorization:
      'Bearer sk_test_9f2c…' } });
const account = await res.json();

// account.balance → 8100000 (int, XOF)

account.php

$ch = curl_init(
  'https://fadpaymoney.com/api/v1/account');
curl_setopt($ch, CURLOPT_HTTPHEADER,
  ['Authorization: Bearer sk_test_9f2c…']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$account = json_decode(curl_exec($ch), true);

// $account['balance'] → 8100000 (int, XOF)

POST /api/v1/transfers — send money to a FadPay Account by email

transfer.sh

curl -X POST \
  https://fadpaymoney.com/api/v1/transfers \
  -H "Authorization: Bearer sk_live_9f2c…" \
  -d '{ "to_email": "m.diop@teranga.digital",
        "amount": 180000, "note": "July salary" }'

# → 201 Created
{ "ok": true, "amount": 180000,
  "balance": 7920000 }

transfer.js

await fetch(
  'https://fadpaymoney.com/api/v1/transfers', {
  method: 'POST',
  headers: { Authorization:
      'Bearer sk_live_9f2c…' },
  body: JSON.stringify({
    to_email: 'm.diop@teranga.digital',
    amount: 180000, note: 'July salary' })
});

transfer.php

$ch = curl_init(
  'https://fadpaymoney.com/api/v1/transfers');
curl_setopt_array($ch, [
  CURLOPT_POST       => true,
  CURLOPT_HTTPHEADER =>
    ['Authorization: Bearer sk_live_9f2c…'],
  CURLOPT_POSTFIELDS => json_encode([
    'to_email' => 'm.diop@teranga.digital',
    'amount' => 180000,
    'note' => 'July salary']),
  CURLOPT_RETURNTRANSFER => true]);
$result = json_decode(curl_exec($ch), true);

Webhooks

Signed events, the moment money moves

Subscribe an HTTPS endpoint once and FadPay calls you back in real time — when a transfer settles, a payout batch completes or a collection lands. No polling, no guessing.

Signed with your whsec_ secret. Each subscription gets its own secret at creation — shown once, stored hashed.
Verify before you trust. Check the X-FadPay-Signature HMAC-SHA256 header against the raw payload on every delivery.
Pick only the events you need. Subscriptions are per-event, and you can send a test delivery from the console any time.

delivery.http

# POST https://api.baobablabs.io/hooks/fadpay
X-FadPay-Signature: t=1770000000,
  v1=hmac_sha256(body, whsec_…)

{
  "event": "payout.completed",
  "data": {
    "reference": "PYT-8F31C2",
    "total": 1440000,
    "count": 8,
    "currency": "XOF"
  }
}

`transfer.completed`

A transfer you sent has settled on the ledger.

`payout.completed`

A bulk payout batch finished — reference, total and count included.

`collection.received`

One of your invoices or payment links was just paid.

`payroll.run`

A payroll run completed and every salary has landed.

`identity.verified`

An identity attribute on the account moved to verified.

`account.updated`

Details on your FadPay Account changed.

Identity & business verification

Verify customers without seeing their data

Lending, hiring, onboarding merchants — you rarely need someone's numbers, you need an answer. FadPay verification gives you exactly that, with the customer's explicit approval.

You ask, the customer approves. Every verification starts as a request the customer sees, understands and explicitly authorizes.
Answers, not numbers. You receive "Eligible", "Verified" or "Income requirement satisfied" — never a balance, a salary or a score.
Businesses too. Confirm a merchant or company attribute the same way before you onboard them.
The Score stays private. GET /score answers 403 everywhere, for everyone. The FadPay Score is owner-only by design.

Authorization answers Customer-approved

Eligibility — Amadou Diop

Eligible

Income — Khady Ndiaye

Requirement satisfied

Identity — Moussa Fall

Verified

No balances. No salaries. No score. Answers only.

Quickstart

Sandbox first, live when you're ready

Test and live keys hit the same API with the same shapes — the only thing that changes when you flip is the money.

Create a developer account

Sign up for FadPay Next and switch on developer access from your console. It takes under a minute and no card is required.

Build in the sandbox

Issue an sk_test_ key and integrate against sandbox data — same endpoints, same responses, nothing real can move. Rotate keys any time.

Flip the key, go live

Swap in an sk_live_ key and your code starts moving real money — ping, read your account, then POST your first transfer.

SDKs

Official libraries for your stack

Skip the boilerplate. Our SDKs wrap authentication, retries and signature checks so you can call FadPay in a couple of lines.

PHP

A Composer package with typed responses and webhook signature helpers.

# install
composer require fadpay/fadpay-php

Node.js

Promise-based, fully typed and ready for serverless runtimes.

// install
npm install @fadpay/sdk

Python

A clean, synchronous client that plays nicely with async too.

# install
pip install fadpay