How can I accurately calculate the gross invoice amount including Stripe and application fees in JavaScript?

Below is one common approach that has helped others match Stripe’s own calculations:

Instead of doing all your math in dollars (floating point), many developers convert the amounts to cents (integers) and then “solve” for the correct gross amount using an iterative (or search) algorithm. This approach mimics how Stripe works internally—always doing fee math on integer cent amounts and applying rounding rules on each fee component. One strategy is:

1. Convert the net amount to cents.
2. Make an initial estimate for the gross (also in cents). For example, you can reverse‑engineer using the formula:
     gross = (net + fixed_fee) / (1 – commission_rate – app_fee_rate)
   (be sure to convert fixed fee and net amounts to cents).
3. Calculate the Stripe fee (fixed + percentage) and your fee (percentage) on that gross amount in cents. Use standard rounding (usually round to the nearest cent) as Stripe does.
4. Check if net cent amount plus the calculated fees equals your gross. If not, adjust the gross (usually adding one cent at a time) until it does.

The following example demonstrates this methodology using JavaScript:

JAVASCRIPTCopied
const stripeCommissionRate = 0.029;
const stripeFixedFeeCents = 30; // $0.30 in cents
const myFeeRate = 0.0146;

// Helper function: rounds to nearest integer (cent)
function roundToCents(amount) {
  return Math.round(amount);
}

function calculateFees(netAmountDollars) {
  // Convert net amount from dollars to cents.
  const netCents = Math.round(netAmountDollars * 100);
  
  // Initial gross estimate.
  let grossCents = Math.ceil((netCents + stripeFixedFeeCents) / (1 - stripeCommissionRate - myFeeRate));
  
  // Iterate until we find a gross value where:
  // netCents + stripeFeeCents + myFeeCents === grossCents.
  while (true) {
    // Compute the fee components on the gross.
    const stripeFeeCents = roundToCents(stripeFixedFeeCents + grossCents * stripeCommissionRate);
    const myFeeCents = roundToCents(grossCents * myFeeRate);
    
    if (netCents + stripeFeeCents + myFeeCents === grossCents) {
      // Matching gross found; break out.
      return {
        grossAmount: (grossCents / 100).toFixed(2),
        stripeFee: (stripeFeeCents / 100).toFixed(2),
        myFee: (myFeeCents / 100).toFixed(2),
        totalFees: ((stripeFeeCents + myFeeCents) / 100).toFixed(2)
      };
    }
    // If not, increment grossCents by one cent and try again.
    grossCents++;
  }
}

// Examples:

console.log(calculateFees(1500.00));  // Expected: gross ~1568.68, fees ~68.68
console.log(calculateFees(1000.00));  // Expected: gross ~1045.90, fees ~45.90
console.log(calculateFees(49.99));    // Expected: gross ~52.59, fees ~2.60
console.log(calculateFees(299.98));   // Expected: gross ~313.98, fees ~13.98

Key Points

• Integer Math: By working in cents (integers), you avoid the small rounding errors inherent when using floating‑point math.
• Incremental Adjustment: Starting from an estimated gross amount and then incrementing one cent at a time ensures you find the smallest amount that meets Stripe’s rounding rules.
• Fee Calculation: The algorithm calculates each fee component as Stripe does—by taking the appropriate percentage of the gross and then rounding to the nearest cent.

This method should now match what Stripe charges for any net amount when using connected accounts.