Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.fyatu.com/llms.txt

Use this file to discover all available pages before exploring further.

Power your fintech application with FYATU’s comprehensive API suite. From neobanks to lending platforms, we provide the infrastructure to build innovative financial services for Africa.

​
The Challenge

Fintech startups in Africa face infrastructure hurdles:
  • Banking partnerships - Difficult and time-consuming to establish
  • Payment rails - Building payment infrastructure from scratch is costly
  • Card issuing - Complex compliance and technical requirements
  • Multi-country expansion - Different regulations and payment systems
  • Speed to market - Long development cycles delay launch

​
The FYATU Solution

Collections

Accept deposits and payments from customers

Payouts

Send disbursements, loans, and withdrawals

Virtual Cards

Issue cards for spending and corporate expenses

Account Verification

Verify recipient accounts before sending money

​
Use Cases by Fintech Type

​
Neobanks & Digital Wallets

Build a full-featured digital banking experience: 
// Accept deposits from Fyatu users into their wallet on your platform
const deposit = await fyatu.collections.create({
  amount: 100.00,
  currency: 'USD',
  reference: `DEP-${walletId}-${Date.now()}`,
  description: 'Wallet top-up',
  customer: {
    email: user.email,
    externalId: user.id
  },
  metadata: {
    walletId: walletId,
    type: 'deposit'
  }
});

// Customer withdraws to their Fyatu wallet
const withdrawal = await fyatu.payouts.create({
  amount: 50.00,
  currency: 'USD',
  reference: `WD-${walletId}-${Date.now()}`,
  recipient: {
    accountId: user.fyatuClientId  // User's Fyatu account ID
  }
});

// Issue virtual card for online spending
const card = await fyatu.cards.create({
  cardholderId: user.cardholderId,
  currency: 'USD',
  type: 'virtual'
});

​
Lending Platforms

Disburse loans and collect repayments: 
// Disburse approved loan to borrower's Fyatu wallet
async function disburseLoan(loan) {
  const payout = await fyatu.payouts.create({
    amount: loan.principalAmount,
    currency: 'USD',
    reference: `LOAN-${loan.id}`,
    description: `Loan disbursement - ${loan.id}`,
    recipient: {
      accountId: loan.borrower.fyatuClientId  // Borrower's Fyatu account ID
    },
    metadata: {
      loanId: loan.id,
      borrowerId: loan.borrowerId,
      type: 'disbursement'
    }
  });

  loan.status = 'disbursed';
  loan.disbursedAt = new Date();
  loan.payoutId = payout.id;
  await loan.save();
}

// Collect loan repayment
async function createRepaymentRequest(loan, amount) {
  const collection = await fyatu.collections.create({
    amount: amount,
    currency: 'USD',
    reference: `REPAY-${loan.id}-${Date.now()}`,
    description: `Loan repayment - ${loan.id}`,
    customer: {
      email: loan.borrower.email,
      phone: loan.borrower.phone
    },
    metadata: {
      loanId: loan.id,
      repaymentType: 'scheduled'
    }
  });

  return collection.checkoutUrl;
}

​
Savings & Investment Apps

Enable deposits and withdrawals for investment products: 
// Investment deposit
const investment = await fyatu.collections.create({
  amount: 500.00,
  currency: 'USD',
  reference: `INV-${portfolioId}-${Date.now()}`,
  description: 'Investment contribution',
  customer: { email: user.email },
  metadata: {
    portfolioId: portfolioId,
    investmentType: 'recurring'
  }
});

// Investment withdrawal/redemption
const redemption = await fyatu.payouts.create({
  amount: withdrawAmount,
  currency: 'USD',
  reference: `REDEEM-${portfolioId}-${Date.now()}`,
  description: 'Investment redemption',
  recipient: { accountId: user.fyatuAccountId },
  metadata: {
    portfolioId: portfolioId,
    units: unitsRedeemed
  }
});

​
Expense Management

Issue virtual cards for employee spending: 
// Create employee cardholder
const cardholder = await fyatu.cardholders.create({
  firstName: employee.firstName,
  lastName: employee.lastName,
  email: employee.email,
  phone: employee.phone,
  externalId: employee.id
});

// Issue expense card with limits
const card = await fyatu.cards.create({
  cardholderId: cardholder.id,
  currency: 'USD',
  type: 'virtual',
  spendingLimit: {
    amount: 1000,
    interval: 'monthly'
  },
  metadata: {
    employeeId: employee.id,
    department: employee.department,
    costCenter: employee.costCenter
  }
});

// Fund the card
await fyatu.cards.fund(card.id, {
  amount: 500,
  reference: `FUND-${employee.id}-${Date.now()}`
});

​
Virtual Card Features

Issue USD virtual cards for your users:
FeatureDescription
Instant IssuanceCards ready to use immediately
Spending ControlsSet per-transaction and periodic limits
Real-time AlertsWebhook notifications for all transactions
Freeze/UnfreezeTemporarily disable cards
Custom MetadataTag cards with your own identifiers

​
Card Transaction Webhooks

app.post('/webhooks/fyatu', (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'card.transaction.authorized':
      // Transaction approved, update user balance display
      notifyUser(event.data.cardholderId, {
        type: 'transaction',
        amount: event.data.amount,
        merchant: event.data.merchantName
      });
      break;

    case 'card.transaction.declined':
      // Transaction declined
      notifyUser(event.data.cardholderId, {
        type: 'declined',
        reason: event.data.declineReason
      });
      break;

    case 'card.transaction.settled':
      // Final settlement, update records
      recordTransaction(event.data);
      break;
  }

  res.status(200).send('OK');
});

​
Account Verification

Verify recipient accounts before sending money: 
// Verify before payout
const verification = await fyatu.accounts.verify(recipientClientId);

if (verification.exists) {
  console.log(`Account found: ${verification.name}`);

  // Show user for confirmation
  const confirmed = await confirmWithUser({
    name: verification.name,
    accountId: recipientClientId
  });

  if (confirmed) {
    await fyatu.payouts.create({
      amount: 100,
      recipient: { accountId: recipientClientId }
    });
  }
} else {
  throw new Error('Recipient account not found');
}

​
Compliance & KYC

​
Cardholder KYC

// Submit KYC documents for card issuance
await fyatu.cardholders.submitKyc(cardholderId, {
  documentType: 'passport',
  documentNumber: 'AB1234567',
  documentFrontUrl: 'https://storage.example.com/passport-front.jpg',
  documentBackUrl: 'https://storage.example.com/passport-back.jpg',
  selfieUrl: 'https://storage.example.com/selfie.jpg'
});

// Listen for KYC result
// Webhook: cardholder.kyc.approved or cardholder.kyc.rejected

​
Transaction Monitoring

All transactions are monitored for suspicious activity. Implement additional checks: 
// Pre-payout velocity check
async function canProcessPayout(userId, amount) {
  const last24h = await getPayoutsLast24Hours(userId);
  const dailyLimit = await getUserDailyLimit(userId);

  if (last24h.total + amount > dailyLimit) {
    return { allowed: false, reason: 'daily_limit_exceeded' };
  }

  return { allowed: true };
}

​
Multi-Country Expansion

FYATU supports multiple African countries with a single integration:
CountryCollectionsPayoutsCards
DRC✅✅✅
Kenya✅✅✅
Uganda✅✅✅
Tanzania✅✅✅
Rwanda✅✅✅
Nigeria✅✅✅

​
Webhooks for Fintech

Essential webhook events for fintech applications:
EventUse Case
collection.completedCredit user wallet/account
payout.completedConfirm loan disbursement
payout.failedRetry or notify user
card.transaction.*Real-time spending alerts
cardholder.kyc.*KYC status updates

​
Getting Started

1

Sign Up

Create a FYATU business account
2

Complete Verification

Submit required fintech business documentation
3

Choose Products

Enable Collections, Payouts, and/or Card Issuing
4

Build & Test

Integrate APIs and test in sandbox environment
5

Launch

Go live and scale your fintech product

​
Resources