Binomial Option Pricing Model: Step-by-Step Guide 2026

In September 1979, John Cox, Stephen Ross and Mark Rubinstein published a paper in the Journal of Financial Economics called "Option Pricing: A Simplified Approach". It ran to about 35 pages, used nothing more advanced than school algebra, and reproduced the Black-Scholes price of an option to any accuracy you liked. Six years after Black and Scholes needed a partial differential equation and stochastic calculus to price a call option, Cox, Ross and Rubinstein got the same answer with a tree.

That tree is the binomial option pricing model, and in 2026 it is still the first pricing model most quants build by hand. Not because it is quaint, but because it does two things Black-Scholes cannot: it prices American options with early exercise, and it shows you exactly why option pricing works, one step at a time.

This guide works through the whole model with real numbers: a one-period example you can check on paper, multi-period trees, the Cox-Ross-Rubinstein parameterisation, American options, convergence to Black-Scholes, and a Python implementation.

---

The One-Period Model

Start with the smallest possible market. A stock trades at S = 100 today. In one year it will be worth exactly one of two things: 110 (an up move, u = 1.1) or 90 (a down move, d = 0.9). The risk-free rate is r = 2% per year, continuously compounded. You want to price a one-year European call option with strike K = 100.

At expiry the option is worth max(S - K, 0). So it pays 10 in the up state and 0 in the down state. The question is what it is worth today.

The answer does not depend on how likely the up move is. That is the surprising part, and it is the heart of the model. Instead of forecasting the stock, you build a portfolio of the stock and a bond that replicates the option's payoff exactly, and the option must cost what the portfolio costs. Anything else is an arbitrage.

Step 1: find the hedge ratio. Buy delta shares so that the portfolio pays the same in both states. Delta is the spread of option payoffs over the spread of stock prices:

delta = (10 - 0) / (110 - 90) = 0.5

Step 2: find the borrowing. Half a share plus a bond position B must equal the option payoff in each state. In the down state the option pays 0, so 0.5 * 90 + B * e^(0.02) = 0, which gives a borrowing with future value 45 and present value 45 * e^(-0.02) = 44.11. Check the up state: 0.5 * 110 - 45 = 10. It replicates.

Step 3: price the option. The replicating portfolio costs 0.5 * 100 - 44.11 = 5.89. So the call is worth 5.89 today. Not roughly 5.89. Exactly, given the model's assumptions.

There is a faster way to organise the same calculation. Define the risk-neutral probability:

q = (e^(r*T) - d) / (u - d) = (1.0202 - 0.9) / (1.1 - 0.9) = 0.6010

Then the option value is the discounted expectation under q:

V = e^(-0.02) * (0.6010 * 10 + 0.3990 * 0) = 0.9802 * 6.010 = 5.89

Same answer. The number q is not anyone's forecast of the stock going up. It is the probability that makes the stock itself earn the risk-free rate, and it is the one-period version of the risk-neutral pricing idea that runs through all of derivatives pricing. Notice what never appeared: the real-world probability of the up move, and any measure of risk appetite. Two investors who disagree violently about where the stock is going must still agree the call is worth 5.89.

---

Multi-Period Trees and Backward Induction

One step is a caricature. The fix is to chop the year into many small steps and let the stock move up or down at each one. After N steps the stock can finish at N + 1 different values, and the tree of intermediate prices recombines: an up move followed by a down move lands in the same place as a down followed by an up, because u * d * S = d * u * S. Recombination is what keeps the tree computationally cheap - N + 1 terminal nodes rather than 2^N paths.

Pricing works backwards, which is why the algorithm is called backward induction:

1. At expiry, set each terminal node to its payoff, max(S - K, 0) for a call.
2. Step back one level. Each node's value is the discounted risk-neutral expectation of its two children: V = e^(-r*dt) * (q * V_up + (1 - q) * V_down).
3. Repeat until you reach the root. The value at the root is the option price.

Every node is a one-period problem exactly like the one we solved by hand. The multi-period model is nothing more than that calculation applied a few thousand times. And because the hedge ratio delta = (V_up - V_down) / (S_up - S_down) exists at every node, the model also hands you a dynamic hedging strategy: it tells you how many shares to hold at every point in the tree, which is the discrete-time ancestor of the delta in the Black-Scholes formula.

---

The Cox-Ross-Rubinstein Parameterisation

Where do u and d come from in practice? Cox, Ross and Rubinstein proposed matching the tree to the volatility of the stock. With annualised volatility sigma and step size dt = T / N:

u = e^(sigma * sqrt(dt)), d = 1 / u

The choice d = 1/u makes the tree recombine around the starting price, which is convenient for building it, and it fixes the size of moves so that the tree's variance matches sigma^2 * dt per step as dt shrinks. The risk-neutral probability keeps the same form as before, q = (e^(r*dt) - d) / (u - d).

With sigma = 20% and 252 steps over one year, dt = 1/252 and u = e^(0.2 * sqrt(1/252)) = 1.0127. Each step the stock moves about 1.27% up or down. That is the whole calibration: one volatility number, exactly as in Black-Scholes.

Other parameterisations exist. Jarrow and Rudd (1983) centre the tree on the risk-neutral drift instead of the spot; Leisen and Reimer (1996) choose parameters that converge faster and more smoothly. CRR remains the default in textbooks and interviews because it is the simplest one that works.

---

Quick quiz

Binomial model check

Then implement CRR in the browser.

1 / 3

In CRR, if u = exp(σ√Δt), then d is typically…

• u²
• 1/u
• −u
• σ

American Options and Early Exercise

Here is where the binomial model earns its keep. An American option can be exercised at any time before expiry, and Black-Scholes has no closed-form answer for an American put. The binomial tree handles it with a one-line change to backward induction. At every node, compare the continuation value with the exercise value and take the larger:

V = max( e^(-r*dt) * (q * V_up + (1 - q) * V_down), K - S )

for a put. That max is the entire theory of early exercise, made computable. Where the intrinsic value wins, the model is telling you to exercise; the boundary between the two regions traces out the early exercise frontier.

For an American put on a non-dividend stock, early exercise is optimal when the option is deep in the money: the interest you earn by receiving the strike now outweighs the remaining time value. For an American call on a non-dividend stock, early exercise is never optimal (a result you can derive from put-call parity), so its binomial price matches the European one. Add a dividend and the call can be worth exercising just before the ex-dividend date - and the tree handles that too, by dropping the stock price at the dividend node.

This is the practical reason the model survives. Most single-stock options listed in the US are American-style. Desks that quote them are running lattice methods, trinomial refinements or finite difference schemes whose logic is the same backward induction you have just seen.

---

Convergence to Black-Scholes

As the number of steps grows, the binomial distribution of the terminal stock price converges to the lognormal distribution assumed by Black-Scholes, and the tree price converges to the Black-Scholes price. This is a central limit theorem argument, and Cox, Ross and Rubinstein spelled it out in the 1979 paper.

The numbers make the point. Take a one-year at-the-money call, S = K = 100, r = 2%, sigma = 20%. Black-Scholes says 8.92. The tree gives:

Convergence is not monotone - the price oscillates around the limit as steps increase, a sawtooth caused by where the strike sits relative to the terminal nodes. Practitioners smooth it by averaging adjacent step counts or using the Leisen-Reimer tree. But the destination is not in doubt: run enough steps and the tree and the Black-Scholes model are the same model, one written in discrete time and one in continuous time.

---

Pricing a European Call in Python

Here is a compact CRR implementation. It builds the terminal prices, applies the payoff and rolls back through the tree with vectorised NumPy operations.

import numpy as np


def crr_european_call(S0, K, r, sigma, T, n_steps):
    """Price a European call on a CRR binomial tree."""
    dt = T / n_steps
    u = np.exp(sigma * np.sqrt(dt))
    d = 1.0 / u
    q = (np.exp(r * dt) - d) / (u - d)      # risk-neutral probability
    disc = np.exp(-r * dt)                  # one-step discount factor

    # Terminal stock prices: S0 * u^j * d^(n-j) for j = 0..n
    j = np.arange(n_steps + 1)
    S_T = S0 * u**j * d**(n_steps - j)

    # Payoff at expiry, then backward induction
    V = np.maximum(S_T - K, 0.0)
    for _ in range(n_steps):
        V = disc * (q * V[1:] + (1 - q) * V[:-1])

    return V[0]


price = crr_european_call(S0=100, K=100, r=0.02, sigma=0.20, T=1.0, n_steps=1000)
print(f"CRR call price: {price:.4f}")   # 8.9160, vs Black-Scholes 8.9160

The backward induction loop is the whole algorithm: at each pass, V[1:] holds the up-children and V[:-1] the down-children, so one line computes the discounted expectation for every node in the level at once. Converting this to an American put takes two changes: swap the payoff to max(K - S, 0), and inside the loop take the maximum of the continuation value and the intrinsic value at each node (which requires tracking the stock prices level by level). Runtime for 1,000 steps is a few milliseconds, and unlike a Monte Carlo simulation there is no sampling error to manage.

---

Where the Model Falls Short

The binomial model inherits every economic assumption of Black-Scholes, and adds a few numerical quirks of its own. Be honest about both.

Constant volatility. One sigma drives the whole tree, so the model produces a flat implied volatility surface. Real markets show smiles and skews at every expiry, which means a single tree cannot reprice the options market it is supposedly modelling. Capturing the smile needs stochastic or local volatility - see our guide to option pricing models for how the alternatives line up.

Constant rates, no frictions. The tree assumes a single known risk-free rate, continuous frictionless hedging, no transaction costs and no jumps. The replication argument that makes the price exact in the model is only approximate in a market where you rebalance discretely and pay spreads.

Slow, oscillating convergence. The sawtooth error means a naive 50-step tree can be off by several basis points of spot, and barrier options are worse: when the barrier falls between node levels, prices converge painfully slowly unless you place nodes on the barrier deliberately.

Dimensionality. Trees scale badly beyond one underlying. A two-asset option needs a lattice at every node pair, and by three or four assets Monte Carlo is the only realistic route.

None of this makes the model a toy. It makes it a well-understood tool with a clearly marked boundary: one underlying, deterministic volatility, early exercise allowed.

---

Frequently Asked Questions

Is the binomial model still used in practice in 2026?

Yes, in two places. First, American-style equity options: lattice and finite difference methods descended directly from the binomial tree remain standard for handling early exercise, because Black-Scholes cannot. Second, education and interviews: the one-period replication argument is the cleanest available proof of risk-neutral pricing, and quant interviewers lean on it heavily. What you will not see is a desk pricing exotic or multi-asset products off a plain CRR tree; those have moved to Monte Carlo and PDE methods with richer dynamics.

How many steps do I need for an accurate price?

For a vanilla European or American option, 500 to 1,000 CRR steps typically gets you within a tenth of a basis point of the continuous-time limit, and the run takes milliseconds. If you need speed, a Leisen-Reimer tree with 101 steps often beats a CRR tree with 1,000. Barrier and digital payoffs are the exception: their discontinuities interact badly with the node grid, and step counts in the tens of thousands may still oscillate unless you adapt the tree to the barrier.

What is the difference between the binomial model and Black-Scholes?

They are the same economic model at different resolutions. The binomial tree describes the stock in discrete time steps with two possible moves per step; Black-Scholes describes it in continuous time with lognormal returns. As the step size shrinks, the tree's prices converge to the Black-Scholes formula. The practical differences: the tree handles American exercise and discrete dividends naturally, while Black-Scholes gives instant closed-form prices and Greeks for European payoffs.

Why doesn't the real probability of an up move matter?

Because the price is set by replication, not by expectation. The option's payoff can be manufactured exactly from a position in the stock and the bond, so its price must equal the cost of that portfolio, whatever anyone believes about the stock's direction. Beliefs about direction are already embedded in today's stock price. The risk-neutral probability q is a bookkeeping device that makes the replication cost look like an expected value - useful, but not a forecast.