Skip to main content
Power your travel business with FYATU. Accept bookings from African travelers, issue virtual cards for travel expenses, and provide eSIM connectivity for international tourists.

​
The Challenge

Travel and hospitality businesses face:
  • Payment diversity - Travelers use various payment methods
  • International connectivity - Tourists need data abroad
  • Corporate travel - Managing employee travel expenses
  • Multi-currency - Handling different currencies for bookings
  • Refunds - Processing cancellations and refunds

​
The FYATU Solution

Collections

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

Travel eSIMs

Provide instant connectivity for travelers in 190+ countries

Virtual Cards

Issue USD virtual Mastercards for corporate travel and expenses

Payouts

Pay partners directly to their Fyatu wallet balances

​
Booking Payments

​
Accept Booking Payment

// Create booking payment
async function createBookingPayment(booking) {
  const collection = await fyatu.collections.create({
    amount: booking.totalAmount,
    currency: 'USD',
    reference: `BOOK-${booking.id}`,
    description: `${booking.type}: ${booking.title}`,
    customer: {
      email: booking.customer.email,
      name: booking.customer.fullName,
      phone: booking.customer.phone
    },
    metadata: {
      bookingId: booking.id,
      bookingType: booking.type, // flight, hotel, tour, etc.
      travelDate: booking.travelDate,
      guests: booking.guestCount
    },
    redirectUrl: `https://yourtravelsite.com/booking/${booking.id}/confirmed`,
    webhookUrl: 'https://api.yourtravelsite.com/webhooks/fyatu'
  });

  booking.paymentId = collection.id;
  booking.checkoutUrl = collection.checkoutUrl;
  await booking.save();

  return collection;
}

​
Handle Booking Confirmation

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

  if (event.type === 'collection.completed') {
    const { bookingId, bookingType } = event.data.metadata;

    const booking = await Booking.findById(bookingId);
    booking.status = 'confirmed';
    booking.paidAt = new Date();
    await booking.save();

    // Send confirmation
    await sendBookingConfirmation(booking);

    // If includes eSIM, purchase it
    if (booking.includesEsim) {
      await purchaseEsimForBooking(booking);
    }
  }

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

​
Travel eSIM Integration

Provide instant connectivity for travelers:

​
List Available Destinations

// Get eSIM destinations for travel search
async function getEsimDestinations() {
  const destinations = await fyatu.esim.getDestinations();

  return destinations.map(dest => ({
    slug: dest.slug,
    name: dest.name,
    type: dest.type, // country or region
    flag: dest.flag,
    startingPrice: dest.packages[0]?.price
  }));
}

​
Show eSIM Packages for Destination

// User is booking a trip to Kenya
async function getEsimPackagesForDestination(slug) {
  const packages = await fyatu.esim.getPackages(slug);

  return packages.map(pkg => ({
    id: pkg.id,
    name: pkg.name,
    data: pkg.data, // e.g., "5GB"
    validity: pkg.validity, // e.g., "30 days"
    price: pkg.price,
    description: pkg.description
  }));
}

​
Bundle eSIM with Booking

// Add eSIM to travel booking
async function addEsimToBooking(bookingId, packageId) {
  const booking = await Booking.findById(bookingId);
  const esimPackage = await fyatu.esim.getPackage(packageId);

  // Add eSIM to booking total
  booking.esimPackageId = packageId;
  booking.esimPrice = esimPackage.price;
  booking.totalAmount += esimPackage.price;
  await booking.save();

  return booking;
}

// After payment, purchase the eSIM
async function purchaseEsimForBooking(booking) {
  const esim = await fyatu.esim.purchase({
    packageId: booking.esimPackageId,
    quantity: 1,
    reference: `ESIM-${booking.id}`,
    metadata: {
      bookingId: booking.id,
      travelerEmail: booking.customer.email
    }
  });

  // Save eSIM details
  booking.esimId = esim.id;
  booking.esimIccid = esim.iccid;
  await booking.save();

  // Send eSIM details to traveler
  await sendEsimDetails(booking.customer.email, {
    qrCode: esim.qrCode,
    activationCode: esim.activationCode,
    instructions: esim.installationInstructions
  });

  return esim;
}

​
Sell eSIM Standalone

// Direct eSIM purchase for travelers
async function purchaseEsim(customer, packageId) {
  // Create payment for eSIM
  const esimPackage = await fyatu.esim.getPackage(packageId);

  const collection = await fyatu.collections.create({
    amount: esimPackage.price,
    currency: 'USD',
    reference: `ESIM-DIRECT-${Date.now()}`,
    description: `Travel eSIM: ${esimPackage.name}`,
    customer: {
      email: customer.email,
      name: customer.fullName
    },
    metadata: {
      packageId: packageId,
      type: 'esim_purchase'
    }
  });

  return collection.checkoutUrl;
}

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

  if (event.type === 'collection.completed' && event.data.metadata.type === 'esim_purchase') {
    const esim = await fyatu.esim.purchase({
      packageId: event.data.metadata.packageId,
      quantity: 1,
      reference: event.data.reference
    });

    // Send to customer
    await sendEsimToCustomer(event.data.customer.email, esim);
  }

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

​
eSIM Top-Up

// Traveler needs more data
async function topUpEsim(esimId, packageId) {
  // Get available top-up packages
  const topupPackages = await fyatu.esim.getTopupPackages(esimId);

  // Create payment for top-up
  const selectedPackage = topupPackages.find(p => p.id === packageId);

  const collection = await fyatu.collections.create({
    amount: selectedPackage.price,
    currency: 'USD',
    reference: `TOPUP-${esimId}-${Date.now()}`,
    description: `eSIM Top-up: ${selectedPackage.name}`,
    metadata: {
      esimId: esimId,
      packageId: packageId,
      type: 'esim_topup'
    }
  });

  return collection.checkoutUrl;
}

// Process top-up after payment
if (event.data.metadata.type === 'esim_topup') {
  await fyatu.esim.topup(event.data.metadata.esimId, {
    packageId: event.data.metadata.packageId
  });
}

​
Corporate Travel Cards

Issue cards for business travelers: 
// Issue travel card for employee
async function issueTravelCard(employee, trip) {
  const cardholder = await fyatu.cardholders.create({
    firstName: employee.firstName,
    lastName: employee.lastName,
    email: employee.email,
    phone: employee.phone,
    externalId: employee.id
  });

  const card = await fyatu.cards.create({
    cardholderId: cardholder.id,
    currency: 'USD',
    type: 'virtual',
    spendingLimit: {
      amount: trip.approvedBudget,
      interval: 'total' // One-time limit
    },
    expiresAt: trip.endDate,
    metadata: {
      employeeId: employee.id,
      tripId: trip.id,
      destination: trip.destination,
      purpose: trip.purpose
    }
  });

  // Fund the card
  await fyatu.cards.fund(card.id, {
    amount: trip.approvedBudget,
    reference: `TRAVEL-${trip.id}`
  });

  return card;
}

​
Track Travel Expenses

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

  if (event.type === 'card.transaction.authorized') {
    const { tripId, employeeId } = event.data.metadata;

    // Log expense
    await TravelExpense.create({
      tripId: tripId,
      employeeId: employeeId,
      amount: event.data.amount,
      merchant: event.data.merchantName,
      category: categorizeExpense(event.data.merchantCategory),
      timestamp: new Date()
    });

    // Check remaining budget
    const trip = await Trip.findById(tripId);
    const totalSpent = await getTripSpending(tripId);
    const remaining = trip.approvedBudget - totalSpent;

    if (remaining < trip.approvedBudget * 0.2) {
      await notifyTravelManager({
        message: `${employee.name}'s travel budget is 80% used`,
        tripId: tripId
      });
    }
  }

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

function categorizeExpense(mcc) {
  const categories = {
    '3000-3999': 'flights',
    '7011': 'hotels',
    '7512': 'car_rental',
    '5812': 'meals',
    '4121': 'taxi'
  };
  // ... categorization logic
}

​
Booking Cancellations & Refunds

async function cancelBooking(bookingId, reason) {
  const booking = await Booking.findById(bookingId);

  // Calculate refund based on cancellation policy
  const refundAmount = calculateRefund(booking);

  if (refundAmount > 0) {
    const refund = await fyatu.refunds.create(booking.paymentId, {
      amount: refundAmount,
      reason: reason,
      reference: `CANCEL-${bookingId}`
    });

    booking.refundId = refund.id;
    booking.refundAmount = refundAmount;
  }

  booking.status = 'cancelled';
  booking.cancelledAt = new Date();
  await booking.save();

  // Send cancellation confirmation
  await sendCancellationEmail(booking, refundAmount);

  return booking;
}

function calculateRefund(booking) {
  const daysUntilTravel = daysBetween(new Date(), booking.travelDate);

  if (daysUntilTravel > 30) return booking.totalAmount; // Full refund
  if (daysUntilTravel > 14) return booking.totalAmount * 0.75; // 75%
  if (daysUntilTravel > 7) return booking.totalAmount * 0.50; // 50%
  if (daysUntilTravel > 2) return booking.totalAmount * 0.25; // 25%
  return 0; // No refund
}

​
Partner Payouts

Pay hotels, tour operators, and partners directly to their Fyatu wallets: 
// Settlement to hotel partner
async function settleWithHotel(bookings, hotel) {
  const totalAmount = bookings.reduce((sum, b) => sum + b.hotelAmount, 0);
  const commission = totalAmount * 0.15; // 15% commission
  const settlementAmount = totalAmount - commission;

  // Pay directly to partner's Fyatu wallet
  const payout = await fyatu.payouts.create({
    amount: settlementAmount,
    currency: 'USD',
    reference: `HOTEL-${hotel.id}-${Date.now()}`,
    description: `Settlement for ${bookings.length} bookings`,
    recipient: {
      accountId: hotel.fyatuClientId  // Partner's Fyatu account ID
    },
    metadata: {
      hotelId: hotel.id,
      bookingIds: bookings.map(b => b.id),
      periodStart: bookings[0].createdAt,
      periodEnd: bookings[bookings.length - 1].createdAt
    }
  });

  return payout;
}

​
Getting Started

1

Sign Up

Create a FYATU business account
2

Configure Apps

Set up Collection App for payments and Issuing App for eSIM/cards
3

Integrate Booking Flow

Add FYATU checkout to your booking process
4

Add eSIM

Integrate eSIM purchasing for travelers
5

Launch

Start accepting bookings and providing connectivity

​
Resources