Understanding N(d1) and N(d2) in the Black-Scholes-Merton formulas

Understanding the terms \(N(d_1)\) and \(N(d_2)\) is central to seeing why the Black-Scholes-Merton (BSM) model prices European options the way it does. They are not arbitrary constants—they encode probabilities about how a normally distributed variable behaves once we have scaled the problem into a risk-neutral world.

Recap of the formulas

For a European call \(c\) and put \(p\) on an underlying asset that pays a continuous dividend yield \(q\), with maturity \(T\), strike \(K\), underlying price \(S_0\), continuously compounded risk-free rate \(r\), and volatility \(\sigma\), the Black-Scholes-Merton (BSM) formulas are:

\[ \begin{aligned} c &= S_0 e^{-qT} N(d_1) - K e^{-rT} N(d_2), \\ p &= K e^{-rT} N(-d_2) - S_0 e^{-qT} N(-d_1), \end{aligned} \]

where

\[ \begin{aligned} d_1 &= \frac{\ln\left(S_0 / K\right) + \left( r - q + \tfrac{1}{2}\sigma^2 \right)T}{\sigma \sqrt{T}}, \\ d_2 &= d_1 - \sigma \sqrt{T}. \end{aligned} \]

Here \(N(\cdot)\) is the cumulative distribution function of a standard normal variable. The logic is that the holder of the physical stock receives the dividend yield, but the holder of the call option does not. The value of the dividends that would have been received must be subtracted from the current stock price. For this reason, the BSM model uses the dividend-adjusted stock price, \(S_0 e^{-qT}\), as the effective underlying price over the life of the option. The \(r-q\) term in \(d_1\) reflects the net cost of carry.

Note

Risk-neutral interpretation

The BSM formula can be interpreted as the present value of the expected payoff at expiration. The two terms in the call formula, \(S_0 e^{-qT} N(d_1)\) and \(K e^{-rT} N(d_2)\), represent a portfolio that replicates the option’s payoff.

\(N(d_2)\): The risk-neutral probability that the option will expire in-the-money (i.e., that \(S_T > K\)), computed under the measure where the stock drifts at \(r-q\). It need not match the historical probability; it is the probability consistent with the forward price path used in the replication.
\(K e^{-rT} N(d_2)\): This is the second term in the formula. It represents the present value of paying the strike price, but only if the option is exercised. It is the strike price \(K\), discounted to today, and weighted by the probability of exercise \(N(d_2)\).
\(S_0 e^{-qT} N(d_1)\): This is the first term. It represents the present value of receiving the stock (or more accurately, a claim on the stock worth \(S_0 e^{-qT}\) today), conditional on the option finishing in the money.
The term \(N(d_1)\) is related to the option’s Delta (its sensitivity to a change in the underlying price). For a non-dividend paying stock (\(q=0\)), the call Delta is \(N(d_1)\) and the put Delta is \(N(d_1) - 1\). With dividends, the call Delta is \(e^{-qT} N(d_1)\) and the put Delta is \(e^{-qT} (N(d_1) - 1)\).

The call option price is the difference between the present value of the contingent asset receipt and the contingent liability payment.

Another way to write the call price

The Black–Scholes–Merton call value can also be expressed as

\[ c = e^{-rT} N(d_2)\left[ \frac{S_0 e^{(r-q)T} N(d_1)}{N(d_2)} - K \right]. \]

This highlights that:

\(e^{-rT}\) is the discount factor that brings future payoffs to present value.
\(N(d_2)\) is the risk-neutral exercise probability.
\(\tfrac{S_0 e^{(r-q)T} N(d_1)}{N(d_2)}\) is the expected stock price conditional on exercise (the forward price, adjusted for the probability of being in the money, gives the conditional expectation).

Multiplying the discounted exercise probability by the conditional expected payoff recovers the same call price as the more familiar \(S_0 e^{-qT} N(d_1) - K e^{-rT} N(d_2)\) formula.

Tip

Deriving the conditional expectation

Under the risk-neutral measure the forward price is \(F_0 = S_0 e^{(r-q)T}\) and \(\ln(S_T / F_0)\) is normal with variance \(\sigma^2 T\). The term \(E\left[ S_T \mathbf{1}_{\{S_T > K\}} \right]\) is the expectation of \(S_T\) but only over the states where the option finishes in the money (the indicator \(\mathbf{1}_{\{S_T > K\}}\) turns all other states to zero). Therefore,

\[ E\left[ S_T \mathbf{1}_{\{S_T > K\}} \right] = S_0 e^{(r-q)T} N(d_1), \]

because the call payoff weights the upper tail of the lognormal distribution. Dividing by the risk-neutral exercise probability \(P(S_T > K) = N(d_2)\) isolates the conditional expectation,

\[ E[S_T \mid S_T > K] = \frac{S_0 e^{(r-q)T} N(d_1)}{N(d_2)}, \]

which is precisely the numerator that appears in the alternative call price representation.

Interactive explorer: from inputs to \(N(d_1)\) and \(N(d_2)\)

Use the sliders to change the option parameters. The calculations update instantly, so you can see how each lever influences \(d_1\), \(d_2\), the associated probabilities, and the call/put values.

import {Inputs, html, tex} from "@observablehq/stdlib"

viewof parameters = Inputs.form({
  S0: Inputs.range([10, 250], {value: 100, step: 1, label: html`Stock price ${tex`S_0`}`}),
  K: Inputs.range([10, 250], {value: 110, step: 1, label: html`Strike ${tex`K`}`}),
  r: Inputs.range([0, 10], {value: 3, step: 0.1, label: html`Risk-free rate ${tex`r`} (%)`}),
  q: Inputs.range([0, 10], {value: 0, step: 0.1, label: html`Dividend yield ${tex`q`} (%)`}),
  sigma: Inputs.range([5, 100], {value: 25, step: 1, label: html`Volatility ${tex`\sigma`} (%)`}),
  T: Inputs.range([0.1, 5], {value: 1, step: 0.1, label: html`Time to maturity ${tex`T`} (years)`})
})

calc = {
  const {S0, K, r, q, sigma, T} = parameters;
  const rDec = r / 100;
  const qDec = q / 100;
  const sigmaDec = sigma / 100;
  const sqrtT = Math.sqrt(T);
  const numerator = Math.log(S0 / K) + (rDec - qDec + 0.5 * sigmaDec ** 2) * T;
  const denominator = sigmaDec * sqrtT;
  const d1 = numerator / denominator;
  const d2 = d1 - sigmaDec * sqrtT;
  const Nd1 = 0.5 * (1 + erf(d1 / Math.SQRT2));
  const Nd2 = 0.5 * (1 + erf(d2 / Math.SQRT2));
  const Nmd1 = 1 - Nd1;
  const Nmd2 = 1 - Nd2;

  const stockPriceDiscountFactor = Math.exp(-qDec * T);
  const strikeDiscountFactor = Math.exp(-rDec * T);

  const call = S0 * stockPriceDiscountFactor * Nd1 - K * strikeDiscountFactor * Nd2;
  const put = K * strikeDiscountFactor * Nmd2 - S0 * stockPriceDiscountFactor * Nmd1;
  
  const callDelta = stockPriceDiscountFactor * Nd1;
  const putDelta = stockPriceDiscountFactor * (Nd1 - 1);
  
  // For decomposition view
  const netGrowthFactor = Math.exp((rDec - qDec) * T);
  const pvExerciseProb = strikeDiscountFactor * Nd2;
  const conditionalExpectation = Nd2 > 1e-9 ? (S0 * netGrowthFactor * Nd1) / Nd2 : NaN;
  const altCall = Number.isFinite(conditionalExpectation) ? strikeDiscountFactor * Nd2 * (conditionalExpectation - K) : NaN;
  
  return {
    d1, d2, Nd1, Nd2, Nmd1, Nmd2,
    call, put,
    callDelta, putDelta,
    S0, K, rDec, qDec, sigmaDec, T,
    strikeDiscountFactor,
    netGrowthFactor,
    pvExerciseProb,
    conditionalExpectation,
    altCall
  };
}

function erf(x) {
  const sign = x >= 0 ? 1 : -1;
  const absX = Math.abs(x);
  const a1 = 0.254829592;
  const a2 = -0.284496736;
  const a3 = 1.421413741;
  const a4 = -1.453152027;
  const a5 = 1.061405429;
  const p = 0.3275911;
  const t = 1 / (1 + p * absX);
  const y = 1 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
  return sign * y;
}

Visualizing the probability density

standardNormalDensityData = Array.from({length: 401}, (_, i) => {
  const x = -4 + (8 / 400) * i;
  const density = (1 / Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * x * x);
  return {x, density};
})

Plot.plot({
  width: 520,
  height: 300,
  x: {label: "z-score"},
  y: {label: "ϕ(z)", domain: [0, 0.45]},
  marks: [
    Plot.areaY(standardNormalDensityData.filter(d => d.x <= calc.d1), {
      x: "x",
      y: "density",
      fill: "#4f46e5",
      fillOpacity: 0.25
    }),
    Plot.line(standardNormalDensityData, {x: "x", y: "density", stroke: "#111827"}),
    Plot.ruleX([calc.d1], {stroke: "#4f46e5", strokeDash: "4,4"}),
    Plot.text([{x: calc.d1, y: 0.06, text: `d₁ = ${calc.d1.toFixed(2)}`}], {x: "x", y: "y", text: "text", fill: "#312e81", fontSize: 12, dy: -5}),
    Plot.text([{x: calc.d1, y: 0.04, text: `N(d₁) = ${calc.Nd1.toFixed(2)}`}], {x: "x", y: "y", text: "text", fill: "#312e81", fontSize: 12, dy: 10})
  ]
})

Plot.plot({
  width: 520,
  height: 300,
  x: {label: "z-score"},
  y: {label: "ϕ(z)", domain: [0, 0.45]},
  marks: [
    Plot.areaY(standardNormalDensityData.filter(d => d.x <= calc.d2), {
      x: "x",
      y: "density",
      fill: "#0ea5e9",
      fillOpacity: 0.25
    }),
    Plot.line(standardNormalDensityData, {x: "x", y: "density", stroke: "#0c4a6e"}),
    Plot.ruleX([calc.d2], {stroke: "#0ea5e9", strokeDash: "4,4"}),
    Plot.text([{x: calc.d2, y: 0.06, text: `d₂ = ${calc.d2.toFixed(2)}`}], {x: "x", y: "y", text: "text", fill: "#0f172a", fontSize: 12, dy: -5}),
    Plot.text([{x: calc.d2, y: 0.04, text: `N(d₂) = ${calc.Nd2.toFixed(2)}`}], {x: "x", y: "y", text: "text", fill: "#0f172a", fontSize: 12, dy: 10})
  ]
})

The charts above show the standard normal density with the shaded region representing the probability mass up to \(d_1\) or \(d_2\)—exactly the integral that yields \(N(d_1)\) and \(N(d_2)\). Slide the inputs to see how each \(d\) shifts along the bell curve.

html`
<div class="nd-results">
  <h3>Key quantities</h3>
  <ul>
    <li>${tex`d_1 = ${calc.d1.toFixed(4)}`}</li>
    <li>${tex`d_2 = ${calc.d2.toFixed(4)}`}</li>
    <li>${tex`N(d_1) = ${calc.Nd1.toFixed(4)}`}</li>
    <li>${tex`N(d_2) = ${calc.Nd2.toFixed(4)}`}</li>
    <li>${tex`N(-d_1) = ${calc.Nmd1.toFixed(4)}`}</li>
    <li>${tex`N(-d_2) = ${calc.Nmd2.toFixed(4)}`}</li>
  </ul>
  <h3>Option values & Deltas</h3>
  <ul>
    <li>${tex`c = ${calc.call.toFixed(4)}`}</li>
    <li>${tex`p = ${calc.put.toFixed(4)}`}</li>
    <li>${tex`\Delta_c = ${calc.callDelta.toFixed(4)}`}</li>
    <li>${tex`\Delta_p = ${calc.putDelta.toFixed(4)}`}</li>
  </ul>
  <h3>BSM decomposition terms</h3>
  <ul>
    <li>${tex`e^{-rT} = ${calc.strikeDiscountFactor.toFixed(4)}`} (Strike discount factor)</li>
    <li>${tex`e^{(r-q)T} = ${calc.netGrowthFactor.toFixed(4)}`} (Net growth factor)</li>
    <li>${tex`e^{-rT} N(d_2) = ${calc.pvExerciseProb.toFixed(4)}`} (PV of exercise probability)</li>
    <li>${tex`\frac{S_0 e^{(r-q)T} N(d_1)}{N(d_2)} = ${Number.isFinite(calc.conditionalExpectation) ? calc.conditionalExpectation.toFixed(2) : "undefined"}`} (Conditional expected stock price)</li>
    <li>${tex`c_{alt} = ${Number.isFinite(calc.altCall) ? calc.altCall.toFixed(4) : "undefined"}`} (Alternative call price)</li>
  </ul>
</div>`

How to read the results

Higher \(S_0\) or lower \(K\) shift both \(d_1\) and \(d_2\) upward, raising \(N(d_2)\) and therefore the call price, since exercise becomes more likely.
Increasing \(T\) boosts the volatility exposure via \(\sigma \sqrt{T}\): even if the option starts out-of-the-money, more time widens the distribution and pushes \(N(d_1)\) and \(N(d_2)\) toward 0.5 or beyond.
Greater volatility \(\sigma\) widens the distribution around the same mean. Because the payoff is convex, higher \(\sigma\) typically pushes the call value up even though the shift in \(d_2\) is ambiguous.
The risk-free rate \(r\) increases the drift (raising call values) and increases the discounting of the strike (also raising call values).
The dividend yield \(q\) lowers the drift (reducing call values) by accounting for the value that the stock investor receives but the option holder does not.

The calculator reinforces why \(N(d_2)\) is often described as the risk-neutral exercise probability: as \(d_2\) grows positive, \(N(d_2)\) approaches 1, so the discounted strike effectively becomes due. Meanwhile, the \(S_0 e^{-qT} N(d_1)\) term encodes the conditional present value of the underlying when the option will be exercised, which is why the call value combines those two pieces exactly as in the BSM formula.