Skip to main content

Take a Commission from Your User's Sale

Learn how to automatically deduct platform fees from user transactions to monetize your SaaS platform or marketplace.

Commission Models​

Percentage-Based Commission​

Most common for marketplaces and SaaS platforms:

function calculateCommission(amount, userTier = 'basic') {
  const commissionRates = {
    basic: 0.05,    // 5%
    premium: 0.03,  // 3%
    enterprise: 0.02 // 2%
  };
  
  return amount * commissionRates[userTier];
}

Fixed Fee + Percentage​

Combination model for better revenue:

function calculateHybridCommission(amount, userTier) {
  const rates = {
    basic: { percentage: 0.02, fixed: 20 },
    premium: { percentage: 0.015, fixed: 15 },
    enterprise: { percentage: 0.01, fixed: 10 }
  };
  
  const tier = rates[userTier];
  return (amount * tier.percentage) + tier.fixed;
}

Implementation​

1. Automatic Commission Deduction​

// Process payment with commission deduction
async function processPaymentWithCommission(userId, paymentData) {
  const user = await getUserById(userId);
  const commissionAmount = calculateCommission(paymentData.amount, user.tier);
  const netAmount = paymentData.amount - commissionAmount;
  
  // Create payment link for full amount
  const paymentLink = await nextapi.paymentLinks.create({
    amount: paymentData.amount,
    currency: 'PHP',
    description: paymentData.description,
    metadata: {
      user_id: userId,
      commission_amount: commissionAmount,
      net_amount: netAmount
    }
  });
  
  return paymentLink;
}

2. Commission Collection via Webhooks​

// Handle payment completion and commission collection
app.post('/webhooks/nextapi', async (req, res) => {
  const event = req.body;
  
  if (event.type === 'payment_link.paid') {
    await collectCommission(event.data);
  }
  
  res.status(200).send('OK');
});

async function collectCommission(paymentData) {
  const { amount, metadata } = paymentData;
  const commissionAmount = metadata.commission_amount;
  const userId = metadata.user_id;
  
  // Credit user wallet with net amount
  await nextapi.wallets.credit(metadata.user_wallet_id, {
    amount: metadata.net_amount,
    currency: 'PHP',
    description: 'Payment received (after commission)',
    reference_id: `PAYMENT-${paymentData.id}`
  });
  
  // Credit platform wallet with commission
  await nextapi.wallets.credit(platformWalletId, {
    amount: commissionAmount,
    currency: 'PHP',
    description: `Commission from user ${userId}`,
    reference_id: `COMMISSION-${paymentData.id}`,
    metadata: {
      user_id: userId,
      payment_id: paymentData.id,
      commission_type: 'automatic'
    }
  });
  
  // Update records
  await recordCommission(userId, {
    payment_id: paymentData.id,
    gross_amount: amount,
    commission_amount: commissionAmount,
    net_amount: metadata.net_amount,
    collected_at: new Date()
  });
}

3. Commission Reporting​

// Generate commission reports
async function generateCommissionReport(startDate, endDate) {
  const commissions = await db.query(`
    SELECT * FROM commissions 
    WHERE collected_at BETWEEN $1 AND $2
    ORDER BY collected_at DESC
  `, [startDate, endDate]);
  
  const report = {
    period: { start: startDate, end: endDate },
    summary: {
      total_commission: commissions.rows.reduce((sum, c) => sum + c.commission_amount, 0),
      total_transactions: commissions.rows.length,
      average_commission: 0,
      top_users: []
    },
    details: commissions.rows
  };
  
  report.summary.average_commission = report.summary.total_commission / report.summary.total_transactions;
  
  // Get top users by commission
  report.summary.top_users = await getTopUsersByCommission(startDate, endDate, 10);
  
  return report;
}

Advanced Features​

Tiered Commission Rates​

function calculateTieredCommission(amount, userVolume) {
  // Volume-based tiers
  if (userVolume > 10000000) return 0.01; // 1% for high volume
  if (userVolume > 1000000) return 0.02;  // 2% for medium volume
  if (userVolume > 100000) return 0.03;   // 3% for low volume
  return 0.05; // 5% for new users
}

Custom Commission Rules​

// Apply special commission rules
async function calculateCustomCommission(userId, amount, productCategory) {
  let commissionRate = 0.05; // Default 5%
  
  // Category-specific rates
  const categoryRates = {
    electronics: 0.03,
    clothing: 0.05,
    digital_goods: 0.10
  };
  
  if (categoryRates[productCategory]) {
    commissionRate = categoryRates[productCategory];
  }
  
  // User-specific overrides
  const user = await getUserById(userId);
  if (user.custom_commission_rate) {
    commissionRate = user.custom_commission_rate;
  }
  
  return amount * commissionRate;
}

Best Practices​

  1. Transparent pricing - Clearly communicate commission rates to users
  2. Real-time tracking - Show users their commission deductions
  3. Flexible models - Support different commission structures
  4. Accurate reporting - Provide detailed commission reports
  5. Compliance - Follow financial regulations for fee collection
  6. User notifications - Alert users about commission deductions
  • [Understanding Your Wallet Structure](../guides/core-concepts/understanding-your-wallet-structure
  • [Build a SaaS Platform with User Wallets](./build-a-saas-platform-with-user-wallets
  • [The Collections Lifecycle](../guides/core-concepts/the-collections-lifecycle