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.

Accept payments from customers across Africa on your e-commerce platform. FYATU provides the payment infrastructure to maximize conversion and serve the African market.

​
The Challenge

E-commerce businesses targeting African customers face:
  • Limited reach - Traditional processors miss Africa’s digital-first consumers
  • Cart abandonment - Complicated checkout flows frustrate customers
  • Settlement delays - Traditional processors hold funds for days
  • Multi-vendor payouts - Marketplaces need to pay sellers efficiently
  • Payment fragmentation - Managing multiple payment integrations

​
The FYATU Solution

Fyatu Checkout

Accept payments from 1M+ Fyatu users paying from their wallets

Instant Confirmation

Real-time payment notifications to reduce order delays

Marketplace Payouts

Automated seller payouts directly to their Fyatu wallets

Refund Support

Process refunds back to customers’ Fyatu wallets

​
Integration Options

Redirect customers to FYATU’s secure, optimized checkout page: 
const checkout = await fyatu.collections.create({
  amount: 75.00,
  currency: 'USD',
  reference: `ORD-${orderId}`,
  description: `Order #${orderId} - ${itemCount} items`,
  customer: {
    email: customer.email,
    name: customer.fullName,
    phone: customer.phone
  },
  metadata: {
    orderId: orderId,
    cartItems: JSON.stringify(cart.items)
  },
  redirectUrl: `https://yourstore.com/order/${orderId}/confirmation`,
  webhookUrl: 'https://yourstore.com/webhooks/fyatu'
});

// Redirect customer
res.redirect(checkout.checkoutUrl);

​
Option 2: E-commerce Plugins

Use our pre-built plugins for popular platforms:

​
Complete Checkout Flow

Customer adds items to cart
              ↓
Customer proceeds to checkout
              ↓
Customer enters shipping details
              ↓
Your backend creates FYATU collection
              ↓
Customer redirected to FYATU checkout
              ↓
Customer selects payment method
              ↓
Customer completes payment
              ↓
FYATU sends webhook to your server
              ↓
Order confirmed, inventory updated
              ↓
Customer sees confirmation page

​
Handling Orders

​
Webhook Handler

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

  switch (event.type) {
    case 'collection.completed':
      await handleSuccessfulPayment(event.data);
      break;

    case 'collection.failed':
      await handleFailedPayment(event.data);
      break;

    case 'collection.expired':
      await handleExpiredPayment(event.data);
      break;

    case 'refund.completed':
      await handleRefundComplete(event.data);
      break;
  }

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

async function handleSuccessfulPayment(data) {
  const orderId = data.metadata.orderId;
  const order = await Order.findById(orderId);

  // Update order status
  order.status = 'paid';
  order.paymentId = data.id;
  order.paidAt = new Date();
  await order.save();

  // Update inventory
  for (const item of order.items) {
    await Product.decrementStock(item.productId, item.quantity);
  }

  // Send confirmation email
  await sendOrderConfirmation(order);

  // Notify seller (for marketplace)
  if (order.sellerId) {
    await notifySeller(order.sellerId, order);
  }
}

​
Marketplace Integration

For multi-vendor marketplaces, automate seller payouts:

​
Split Payments

// Order paid, now pay the seller
async function payoutToSeller(order) {
  const seller = await Seller.findById(order.sellerId);

  // Calculate seller share (e.g., 85% of order value)
  const platformFee = order.total * 0.15;
  const sellerAmount = order.total - platformFee;

  const payout = await fyatu.payouts.create({
    amount: sellerAmount,
    currency: 'USD',
    reference: `PAYOUT-${order.id}`,
    description: `Sale: Order #${order.id}`,
    recipient: {
      accountId: seller.fyatuAccountId
    },
    metadata: {
      orderId: order.id,
      sellerId: seller.id,
      platformFee: platformFee
    }
  });

  // Track payout
  await SellerPayout.create({
    orderId: order.id,
    sellerId: seller.id,
    amount: sellerAmount,
    payoutId: payout.id,
    status: 'processing'
  });
}

​
Batch Seller Payouts

For daily/weekly settlement cycles: 
// Daily payout job
async function processSellerPayouts() {
  const pendingPayouts = await getPendingSellerPayouts();

  // Group by seller
  const bySellerSeller = groupBy(pendingPayouts, 'sellerId');

  for (const [sellerId, orders] of Object.entries(bySeller)) {
    const totalAmount = orders.reduce((sum, o) => sum + o.sellerAmount, 0);

    await fyatu.payouts.create({
      amount: totalAmount,
      currency: 'USD',
      reference: `BATCH-${sellerId}-${Date.now()}`,
      description: `Settlement for ${orders.length} orders`,
      recipient: { accountId: seller.fyatuAccountId },
      metadata: {
        sellerId: sellerId,
        orderIds: orders.map(o => o.id),
        periodStart: orders[0].paidAt,
        periodEnd: orders[orders.length - 1].paidAt
      }
    });
  }
}

​
Refunds

Process refunds for returns and cancellations: 
async function processRefund(orderId, reason, amount = null) {
  const order = await Order.findById(orderId);

  // Full or partial refund
  const refundAmount = amount || order.total;

  const refund = await fyatu.refunds.create(order.paymentId, {
    amount: refundAmount,
    reason: reason,
    reference: `REF-${orderId}-${Date.now()}`,
    metadata: {
      orderId: orderId,
      refundType: amount ? 'partial' : 'full'
    }
  });

  // Update order
  order.refundedAmount = (order.refundedAmount || 0) + refundAmount;
  order.status = refundAmount >= order.total ? 'refunded' : 'partially_refunded';
  await order.save();

  // Notify customer
  await sendRefundNotification(order, refundAmount);

  return refund;
}

​
Why Fyatu Payments?

BenefitDescription
1M+ UsersAccess Fyatu’s growing user base across Africa
Instant PaymentsCustomers pay from their Fyatu wallet in seconds
No ChargebacksWallet-to-wallet payments are final and secure
Simple RefundsRefund back to customers’ Fyatu wallets with one API call
Instant SettlementFunds available in your business wallet immediately
Fyatu users can fund their wallets using various local payment methods, giving your store access to African shoppers without managing multiple payment integrations.

​
Optimizing Conversion

​
Best Practices

  1. Promote Fyatu - Highlight Fyatu as a payment option for your African customers
  2. Display prices in local currency - Reduce friction with familiar amounts
  3. Mobile-first checkout - Most African users shop on mobile
  4. Guest checkout - Don’t require account creation
  5. Order tracking - Provide real-time updates

​
Cart Recovery

Handle abandoned carts when payment expires: 
if (event.type === 'collection.expired') {
  const order = await Order.findById(event.data.metadata.orderId);

  // Mark as abandoned
  order.status = 'abandoned';
  await order.save();

  // Send recovery email
  await sendCartRecoveryEmail(order.customer.email, order);
}

​
Pricing

Transaction TypeDescription
CollectionPercentage fee on received payments
Payout (marketplace)Flat fee per payout to sellers
RefundFree (original fee not returned)
Contact sales for volume pricing

​
Getting Started

1

Create Account

Sign up for a FYATU business account
2

Choose Integration

Use a plugin or integrate directly with our API
3

Configure Webhooks

Set up webhook endpoint to receive payment notifications
4

Test Checkout

Test the complete flow in sandbox mode
5

Go Live

Switch to production and start selling

​
Resources