Insurance Premium Collection with Paystack

When a customer signs up for a policy, collect their card and get a reusable authorization code. Use a small charge (e.g., NGN 50) that you refund immediately, or a zero-value charge if Paystack supports it on your account.

// Step 1: Initialize a tokenization payment
app.post('/api/policy/enroll', async (req, res) => {
  var { email, policyNumber, premium } = req.body;

  var reference = 'enroll_' + policyNumber + '_' + Date.now();

  var response = await fetch('https://api.paystack.co/transaction/initialize', {
    method: 'POST',
    headers: {
      Authorization: 'Bearer ' + process.env.PAYSTACK_SECRET_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      email,
      amount: 5000, // NGN 50 tokenization charge
      reference,
      metadata: {
        policy_number: policyNumber,
        action: 'card_tokenization',
      },
    }),
  });

  var data = await response.json();
  res.json({ authorization_url: data.data.authorization_url, reference });
});

// Step 2: After payment, verify and store the authorization_code
app.post('/api/policy/confirm-enrollment', async (req, res) => {
  var { reference } = req.body;

  var verifyRes = await fetch(
    'https://api.paystack.co/transaction/verify/' + reference,
    { headers: { Authorization: 'Bearer ' + process.env.PAYSTACK_SECRET_KEY } }
  );
  var data = await verifyRes.json();

  if (data.data.status === 'success') {
    var auth = data.data.authorization;
    await db.policies.update({
      authorization_code: auth.authorization_code,
      card_last4: auth.last4,
      card_brand: auth.brand,
      card_reusable: auth.reusable,
    }, { where: { policy_number: data.data.metadata.policy_number } });

    // Optionally refund the NGN 50 tokenization charge
    await refundTransaction(reference);

    res.json({ enrolled: true });
  }
});

// collect-premiums.js — runs daily at 8am
async function collectDuePremiums() {
  var today = new Date().toISOString().split('T')[0];

  var duePolicies = await db.policies.findAll({
    where: {
      status: 'active',
      next_premium_date: today,
      authorization_code: { notNull: true },
    }
  });

  for (var policy of duePolicies) {
    var reference = 'premium_' + policy.policy_number + '_' + Date.now();

    var response = await fetch('https://api.paystack.co/transaction/charge_authorization', {
      method: 'POST',
      headers: {
        Authorization: 'Bearer ' + process.env.PAYSTACK_SECRET_KEY,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        email: policy.customer_email,
        amount: Math.round(policy.premium_amount * 100),
        authorization_code: policy.authorization_code,
        reference,
        metadata: {
          policy_number: policy.policy_number,
          billing_period: today,
        },
      }),
    });

    var data = await response.json();

    if (data.data?.status === 'success') {
      await db.policies.update({
        last_paid_date: today,
        next_premium_date: getNextBillingDate(today, policy.billing_cycle),
        failed_attempts: 0,
      }, { where: { id: policy.id } });
    } else {
      // Failed — dunning will handle via webhook
      console.error('Premium collection failed for', policy.policy_number, data.data?.gateway_response);
    }
  }
}

function getNextBillingDate(from, cycle) {
  var date = new Date(from);
  if (cycle === 'monthly') date.setMonth(date.getMonth() + 1);
  if (cycle === 'quarterly') date.setMonth(date.getMonth() + 3);
  if (cycle === 'annually') date.setFullYear(date.getFullYear() + 1);
  return date.toISOString().split('T')[0];
}

// Handle failed charge via charge.failed webhook
if (event.event === 'charge.failed') {
  var policyNumber = event.data.metadata?.policy_number;
  if (!policyNumber) return;

  var policy = await db.policies.findByPolicyNumber(policyNumber);
  var failedAttempts = (policy.failed_attempts || 0) + 1;

  if (failedAttempts >= 3) {
    // Lapse the policy
    await db.policies.update({
      status: 'lapsed',
      lapsed_at: new Date().toISOString(),
      failed_attempts: failedAttempts,
    }, { where: { policy_number: policyNumber } });
    await sendPolicyLapseNotification(policy.customer_email, policyNumber);
  } else {
    // Schedule retry: +3 days for attempt 1, +7 days for attempt 2
    var daysUntilRetry = failedAttempts === 1 ? 3 : 7;
    var retryDate = new Date();
    retryDate.setDate(retryDate.getDate() + daysUntilRetry);

    await db.policies.update({
      failed_attempts: failedAttempts,
      next_premium_date: retryDate.toISOString().split('T')[0],
    }, { where: { policy_number: policyNumber } });

    await sendPaymentFailedNotification(policy.customer_email, { failedAttempts, retryDate });
  }
}

This guide is part of the Paystack recurring billing series.

Sign up for the McTaba newsletter