Build a Crypto Position-Risk Calculator in JavaScript

Largo Winch — Mon, 31 Aug 2026 05:17:22 +0000

AI disclosure: This article was prepared with AI assistance from my real trading notes, calculations, and review. The code and examples were checked before publication.

Leverage is often the first number traders look at, but it is not the number that tells us how many dollars a stop-loss may cost. A more useful pre-trade calculation combines position quantity, entry price, stop price, fees, and a slippage buffer.

I learned the importance of that calculation after losing about $100 on a leveraged trade where I forgot to place a stop. The market analysis was not the main failure; the position had no predefined protection. Since then, I have wanted a small tool that answers the risk question before an order is placed.

In this tutorial, we will build that tool in plain JavaScript.

The simplified model

For a linear USDT-margined position, the price loss between the entry and stop can be approximated as:

price loss = quantity × |entry price - stop price|

For example, a position of 1,500 tokens entered at $0.620 with a stop at $0.608 has a stop distance of $0.012 per token:

1,500 × 0.012 = $18

That $18 does not yet include trading fees or slippage.

Leverage changes the margin required to control the position. It does not change the dollar loss created by the same quantity moving through the same price distance.

Implementing the calculator

function calculatePositionRisk({
  side,
  quantity,
  entryPrice,
  stopPrice,
  leverage = 1,
  entryFeeRate = 0,
  exitFeeRate = 0,
  slippageRate = 0,
}) {
  const numericInputs = {
    quantity,
    entryPrice,
    stopPrice,
    leverage,
    entryFeeRate,
    exitFeeRate,
    slippageRate,
  };

  for (const [name, value] of Object.entries(numericInputs)) {
    if (!Number.isFinite(value) || value < 0) {
      throw new TypeError(`${name} must be a non-negative number`);
    }
  }

  if (quantity === 0 || entryPrice === 0 || stopPrice === 0) {
    throw new RangeError("quantity and prices must be greater than zero");
  }

  if (leverage < 1) {
    throw new RangeError("leverage must be at least 1");
  }

  if (!['long', 'short'].includes(side)) {
    throw new RangeError("side must be 'long' or 'short'");
  }

  const stopIsProtective =
    side === 'long' ? stopPrice < entryPrice : stopPrice > entryPrice;

  if (!stopIsProtective) {
    throw new RangeError(`stopPrice is not protective for a ${side} position`);
  }

  const notional = quantity * entryPrice;
  const stopNotional = quantity * stopPrice;
  const priceLoss = quantity * Math.abs(entryPrice - stopPrice);
  const entryFee = notional * entryFeeRate;
  const estimatedExitFee = stopNotional * exitFeeRate;
  const slippageBuffer = stopNotional * slippageRate;
  const estimatedTotalRisk =
    priceLoss + entryFee + estimatedExitFee + slippageBuffer;
  const approximateMargin = notional / leverage;

  return {
    notional,
    approximateMargin,
    stopDistance: Math.abs(entryPrice - stopPrice),
    stopDistancePercent:
      (Math.abs(entryPrice - stopPrice) / entryPrice) * 100,
    priceLoss,
    entryFee,
    estimatedExitFee,
    slippageBuffer,
    estimatedTotalRisk,
  };
}

The validation catches a surprisingly common mistake: placing the stop on the wrong side of the entry. A protective stop for a long position must sit below the entry, while a protective stop for a short position must sit above it.

Running the example

Fee rates vary by exchange, account tier, and order type, so they must be passed as inputs rather than hard-coded as universal values.

const result = calculatePositionRisk({
  side: 'long',
  quantity: 1500,
  entryPrice: 0.620,
  stopPrice: 0.608,
  leverage: 10,
  entryFeeRate: 0.0005,
  exitFeeRate: 0.0005,
  slippageRate: 0.0005,
});

console.table(result);

Rounded to two decimals, the important outputs are:

console.log({
  notional: result.notional.toFixed(2),
  margin: result.approximateMargin.toFixed(2),
  priceLoss: result.priceLoss.toFixed(2),
  totalRisk: result.estimatedTotalRisk.toFixed(2),
});

The notional value is approximately $930, while the approximate margin at 10x is $93. The price loss at the stop remains $18, before the additional fee and slippage estimates.

Calculating the maximum quantity

We can also solve the problem in reverse: given a dollar-risk budget, what is the maximum quantity?

function calculateMaxQuantity({
  riskBudget,
  entryPrice,
  stopPrice,
  entryFeeRate = 0,
  exitFeeRate = 0,
  slippageRate = 0,
}) {
  const riskPerUnit =
    Math.abs(entryPrice - stopPrice) +
    entryPrice * entryFeeRate +
    stopPrice * exitFeeRate +
    stopPrice * slippageRate;

  if (!Number.isFinite(riskBudget) || riskBudget <= 0) {
    throw new RangeError('riskBudget must be greater than zero');
  }

  if (!Number.isFinite(riskPerUnit) || riskPerUnit <= 0) {
    throw new RangeError('risk per unit must be greater than zero');
  }

  return riskBudget / riskPerUnit;
}

const maxQuantity = calculateMaxQuantity({
  riskBudget: 25,
  entryPrice: 0.620,
  stopPrice: 0.608,
  entryFeeRate: 0.0005,
  exitFeeRate: 0.0005,
  slippageRate: 0.0005,
});

console.log(maxQuantity.toFixed(2));

In a real trading interface, I would round the result down to the exchange's permitted lot step. Rounding up could exceed the chosen risk budget.

What this calculator does not know

This is deliberately a pre-trade estimate, not a liquidation engine or price predictor. It does not account for every contract specification, funding payment, tiered maintenance margin rule, partial fill, gap, or exchange-specific fee detail.

Before using the result, verify:

whether the contract is linear or inverse;
the contract multiplier and lot step;
isolated versus cross margin;
the estimated liquidation price;
the applicable maker or taker fee;
the stop trigger type;
whether the protective order covers the full position.

A stop order is protection, not a promise of an exact fill. Fast markets can move beyond the trigger price.

Conclusion

The useful question is not only “How much could this trade make?” It is “How much should it lose if the idea is wrong?”

A small calculator cannot make a trade safe, but it can force the risk decision to happen before the market starts moving. For me, that is already a meaningful improvement over relying on memory and emotion.

Risk notice: Trading cryptocurrency derivatives involves significant risk and may not be suitable for everyone. Leverage amplifies gains and losses. This tutorial is educational and describes personal experience; it is not financial advice.

Referral disclosure

If you have independently decided to consider OKX, my referral link is:

https://okx.com/join/34107975

Referral code: 34107975

This article contains a referral link, and I may receive a reward if the applicable program conditions are met. Eligibility, tasks, availability, and rewards vary by region and can change. Review the current terms shown in your own OKX account before registering. Using the link would also help me earn a little additional income for my family, but please never trade money you cannot afford to lose.

DEV Community: Largo Winch