Payout Split Calculator
Belocate · Payout Model

Five fixes for how money and risk move through an order

Every section below is the fix — how it works, the formula behind it, a worked example, and a live visualization. No cap, tier, or radius is allowed to sit below the real cost it needs to cover.

1 / 5

Platform commission

A flat 10% scales the fee linearly with order value, but Razorpay's own cut and support/packaging overhead don't grow at the same rate — so a flat cap on the commission can quietly fall below the real payment-processing cost on large orders. The fix below has already been run against every order size from ₹50 to ₹50,000 with zero negative margin.

Solution — fixed + capped %, floored at real cost

Split the fee into the part that's genuinely fixed per order and the part that genuinely scales, cap it so big orders aren't overcharged — then add one more rule: the cap is never allowed to sit under the real, uncapped Razorpay fee plus a guaranteed minimum margin. If the cap would starve the platform, the floor overrides it.

  • 1
    Fixed component (₹6): covers the near-constant per-order cost — packaging check, support overhead, ledger entry — regardless of order size.
  • 2
    Percentage component (4%): covers what genuinely scales with value — fraud exposure and refund risk.
  • 3
    Band it (₹12–₹180): a small order still pays a usable minimum; a mid-size order never sees the fee explode past ₹180.
  • 4
    Cost floor (2% × value + ₹10): at high order values the ₹180 cap alone would sit below Razorpay's real fee — this floor makes the fee float upward past the cap exactly enough to stay ₹10 ahead of that real cost, every time.
fee = max( clamp(₹6 + 4% × value, min ₹12, max ₹180), ← the everyday cap (2% × value) + ₹10 ← real Razorpay cost + margin )

Worked example across order sizes

Order valueOld flat 10%New feeMargin above Razorpay cost
₹100₹10₹12+₹10
₹500₹50₹26+₹16
₹2,000₹200₹86+₹46
₹5,000₹500₹180+₹80
₹10,000₹1,000₹210+₹10
₹15,000₹1,500₹310+₹10
₹25,000₹2,500₹510+₹10

Past ₹10,000 the margin holds flat at exactly +₹10 — the floor is doing its job. It never dips to zero or negative, at any order size.

Visualization — fee as order value grows, ₹100 to ₹15,000
01002003004001005k10k15k₹1,500 (off-chart) →₹310, floor-protected
Flat 10% — keeps climbing, unbounded Fixed + capped %, cost-floored — never goes negative
2 / 5

Delivery partner pay

Distance, weight, vehicle, and weather each change what a delivery actually costs a rider to complete — one flat fee is always wrong for most of them.

Solution — layered, capped surge

Start from a distance tier that covers the baseline trip, add a weight surcharge only past a free allowance, add a flat vehicle adjustment when a bigger vehicle is genuinely required, then add a weather/traffic surge that is itself capped — so a single storm never spikes the customer's price unpredictably. The platform's logistics margin absorbs what the surge cap doesn't cover, not the customer or the partner.

fee = distance_tier(km) + max(0, kg − 3) × ₹5 + vehicle_adjust (bike ₹0, van ₹20) + min(₹30, 15% × subtotal) if bad conditions

Run any combination below — order value, distance, weight, vehicle, weather — and watch the full three-way split (seller / delivery partner / platform) update live, down to the last rupee.

Visualization — run any order through the full split live
Heavy rain / high traffic right now
99%
4%
2%
Seller Delivery partner Platform
Customer pays
₹12,674
Seller receives
₹12,338
Delivery partner
₹65
Platform keeps
₹19
Item price₹12,600
Platform commission (fixed + %, capped)−₹262
Delivery — distance tier₹50
Delivery — weight surcharge+₹24
Delivery — vehicle adjustment₹0
Delivery — weather/traffic (capped)₹0
Razorpay's cut (pass-through, ~2%)−₹252 (est.)
Customer's total bill₹12,674
3 / 5

Service radius & delivery feasibility

Today, shop discovery, delivery pricing, and partner-availability checks are three systems that don't agree on distance: discovery allows matches up to 10km, delivery pricing flattens at ₹40 for the entire 8–10km band, and the availability check only confirms a partner is online somewhere near the shop — never near the customer, and never checks whether the fee for that specific trip is worth accepting. Near the edge of the radius this can accept a paid order that then finds no willing partner.

Solution — continuous pricing + real feasibility check + distance-aware guard bands
  • 1
    Make delivery pricing continuous, not flattened. Replace the tier that caps at ₹40 for 8–10km with a base fee plus a genuine per-km rate that keeps scaling all the way to the radius edge. A 9.8km trip must pay meaningfully more than a 6km trip — never the same.
  • 2
    Check the actual trip, not a generic "partner exists somewhere." Before payment, confirm a partner is online within reach of the customer's drop-off point specifically — not just near the shop — and that the computed fee for that distance clears the minimum ₹/km partners have agreed to accept. If either check fails, the order is rejected up front, cleanly, before money moves — the same fail-fast principle already used for stock reservation.
  • 3
    Add guard bands instead of one hard cliff at 10km. Inside ~7km, the existing generic check is fine — the partner pool is deep. From ~7–10km, require a partner confirmed specifically for that route before checkout is even allowed to proceed, since the willing-partner pool thins out the farther the trip goes.
delivery_fee(km) = ₹12 + ₹6 × km ← continuous, no flattening checkout_allowed = partner_online_near(customer_location) AND delivery_fee(km) ≥ partner_min_acceptable_rate AND (km < 7 OR route_specifically_confirmed)

What this changes at the distances that matter most

DistanceOld flat-tier feeNew continuous feeFeasibility band
1 km₹15₹18Open
2 km₹15₹24Open
4 km₹20₹36Open
6 km₹30₹48Open
8 km₹35₹60Watch — route confirmation required
10 km₹40₹72Watch — route confirmation required

At the radius edge, the old model underpaid a 10km trip by nearly half of what it's actually worth — exactly the gap that makes partners quietly decline the job after a customer has already paid. The new fee closes that gap, and the guard band makes sure a partner was actually findable before the money moved at all.

Visualization — fee vs. distance, with feasibility bands overlaid
0204060800km2km4km6km8km10km₹40₹72
Old flat-tier fee — flattens at ₹40 New continuous fee — keeps scaling
0–7 km · open 7–10 km · route confirmation required
4 / 5

Returns & refunds

A return doesn't undo the work already done — the rider already made the trip, and Razorpay already took its cut. Neither reverses just because the sale did.

Solution — fault-based split, return trip paid as its own job

Decide fault first, then apply it consistently. Merchant's fault → the customer gets a full refund (goods + original delivery) and the seller absorbs the return trip. Customer's fault → the return-trip cost is deducted from their refund instead. Either way the delivery partner is paid for the return trip as a new job on top of the original delivery — never clawed back — and the sunk Razorpay fee on the original payment is priced into the platform's margin buffer, not clawed from anyone.

if merchant_fault: customer_refund = order_value + original_delivery_fee seller_pays = return_trip_fee else: // customer_fault customer_refund = max(0, order_value − return_trip_fee) seller_pays = 0 delivery_partner_gets += return_trip_fee × 0.88 // paid regardless of fault

Try both fault scenarios and both refund methods on the order you configured above — the ledger below updates live.

Visualization — model a return on the order configured in category 2
Customer gets back₹12,800 to wallet, instantly
Seller's extra cost (return-trip delivery)−₹74
Delivery partner — return-trip pay (added to original)+₹65
Platform's cost for this return−₹126 (instant-wallet bonus)
5 / 5

Refund method

Once a refund is due, how it's paid back changes what it costs — a bank refund and a wallet credit are not the same transaction underneath.

Solution — instant wallet credit as the default

Offer instant wallet credit as the default refund path. No Razorpay reversal call is made, so the original payment stays captured and its fee is never at risk. Share half of that saved fee with the customer as an instant top-up bonus; keep the other half as pure margin improvement over a bank refund. Reserve the slow 3–7 day bank refund for customers who explicitly ask for it by name.

wallet_refund = base_refund + (razorpay_fee × 50%) // instant, fee never lost bank_refund = base_refund // 3–7 days, razorpay_fee lost for good

Cost comparison across order sizes

Order valueBank refund costWallet credit costCustomer wait
₹100₹2.00₹1.000 vs 3–7 days
₹450₹9.00₹4.500 vs 3–7 days
₹2,000₹40.00₹20.000 vs 3–7 days
₹10,000₹200.00₹100.000 vs 3–7 days
Visualization — platform's cost per return, wallet vs bank, across order sizes
Top bar = bank refund cost · bottom bar = wallet-credit cost, per order size
₹100 order
−₹2
−₹1
₹450 order
−₹9
−₹5
₹2,000 order
−₹40
−₹20
₹10,000 order
−₹200
−₹100
All five fixes share one shape: separate what's genuinely fixed-cost from what scales, price the variance into a shared buffer instead of surprising any one party, and never let a cap, tier, or radius sit below the real cost it's supposed to cover — commission floors at Razorpay's real fee, delivery pay floors at what a trip really costs, the service radius floors delivery fees at a rate partners will actually accept, and refunds default to the path that never puts the gateway fee at risk. Nothing here reaches zero variance on every single order — the buffer is what turns "sometimes one delivery or one refund is expensive" into "on average, and even at the edges, nobody structurally loses."