Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Binomial Tree Option Pricing › Pricing American Options

Michael BrenndoerferDecember 1, 20258 min read

Quantitative FinanceAll chapters

Part 6 of 15Numerical Methods for Derivative Pricing

Chapter 33Binomial Tree Option Pricing › Pricing American Options

Reading section 5 of 12 · Pricing American Options · 8 minSection 5 of 12 · 8 min

Section 5 of 12 · 8 min read

Binomial Tree Option Pricing › Pricing American OptionsOne section · Sections in this chapter5 / 12 ↓

Sections in this chapter12

Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

The real power of binomial trees emerges when pricing American options, which can be exercised at any time before expiration. Unlike European options, American options have no known closed-form solution except in special cases (American calls on non-dividend-paying stocks are never optimally exercised early and thus equal European calls). The ability to exercise early adds a layer of complexity that continuous-time methods handle poorly, but binomial trees address naturally through backward induction.

Early Exercise DecisionLink Copied

At each node in the tree, you face a choice: exercise now or continue holding. The optimal strategy is to exercise if and only if the immediate exercise value exceeds the continuation value:

f_{i,j}^{\text{American}} = \max\left(\text{Exercise Value}, \text{Continuation Value}\right)

where:

$f_{i,j}^{\text{American}}$ : American option value at node $(i,j)$
$\text{Exercise Value}$ : immediate payoff from exercising the option
$\text{Continuation Value}$ : discounted expected value of holding the option

This simple modification to the backward induction algorithm turns the European pricing method into an American pricing method. At each node, rather than automatically using the continuation value as we would for a European option, we compare it to the immediate exercise value and take the larger of the two.

For an American put at node $(i, j)$ :

f_{i,j} = \max\left(K - S_{i,j}, \, e^{-r\Delta t}[p \cdot f_{i+1,j+1} + (1-p) \cdot f_{i+1,j}]\right)

where:

$K - S_{i,j}$ : immediate exercise value (intrinsic value)
$e^{-r\Delta t}[\dots]$ : continuation value (discounted expected future value)
$p$ : risk-neutral probability
$f_{i,j}$ : option value at node $(i,j)$
$K$ : strike price
$S_{i,j}$ : stock price at node $(i,j)$
$r$ : risk-free interest rate
$\Delta t$ : time step

The first term is the immediate payoff from exercising; the second is the discounted expected value from waiting. By evaluating this comparison at every node, the algorithm finds the optimal exercise strategy and the corresponding option value.

Why American Puts May Be Exercised EarlyLink Copied

For American puts, early exercise can be optimal when the stock price is sufficiently low. Consider a deep in-the-money put with strike $100 and stock price $10. Exercising immediately gives $90. Waiting means:

You tie up $90 of potential proceeds
The maximum additional gain is $10 (if the stock goes to zero)
You risk the stock rising, reducing your payoff

When the time value of money on the exercise proceeds exceeds the expected gain from waiting, early exercise is optimal. The $90 in immediate cash can be invested at the risk-free rate, earning interest. Meanwhile, the probability that the stock falls further to provide additional gains may be low, and the risk that it rises is significant. This trade-off creates a critical stock price below which early exercise is optimal, known as the early exercise boundary.

In[14]:

Code

import numpy as np


def binomial_tree_american(S0, K, T, r, sigma, N, option_type="call"):
    """
    Price an American option using a binomial tree.

    Returns both the option price and a matrix showing where early
    exercise is optimal.
    """
    dt = T / N
    u = np.exp(sigma * np.sqrt(dt))
    d = 1 / u
    p = (np.exp(r * dt) - d) / (u - d)
    disc = np.exp(-r * dt)

    # Build the stock price tree
    S = np.zeros((N + 1, N + 1))
    for i in range(N + 1):
        for j in range(i + 1):
            S[i, j] = S0 * (u**j) * (d ** (i - j))

    # Initialize option values at maturity
    f = np.zeros((N + 1, N + 1))
    if option_type == "call":
        f[N, :] = np.maximum(S[N, :] - K, 0)
    else:
        f[N, :] = np.maximum(K - S[N, :], 0)

    # Track early exercise
    early_exercise = np.zeros((N + 1, N + 1), dtype=bool)

    # Backward induction with early exercise check
    for i in range(N - 1, -1, -1):
        for j in range(i + 1):
            # Continuation value
            cont_value = disc * (p * f[i + 1, j + 1] + (1 - p) * f[i + 1, j])

            # Exercise value
            if option_type == "call":
                exercise_value = max(S[i, j] - K, 0)
            else:
                exercise_value = max(K - S[i, j], 0)

            # American option: take the maximum
            if exercise_value > cont_value:
                f[i, j] = exercise_value
                early_exercise[i, j] = True
            else:
                f[i, j] = cont_value

    return f[0, 0], S, f, early_exercise

In[15]:

Code

# Compare European and American put prices
S0 = 100
K = 100
T = 1
r = 0.05
sigma = 0.2
N = 100

european_put = binomial_tree_european(S0, K, T, r, sigma, N, "put")
american_put, _, _, _ = binomial_tree_american(S0, K, T, r, sigma, N, "put")
premium = american_put - european_put

Out[16]:

Console

European Put Price: $5.5536
American Put Price: $6.0824
Early Exercise Premium: $0.5288

The American put is worth more than the European put because you have the valuable option to exercise early. This difference is called the early exercise premium and it represents the economic value of the flexibility to choose when to exercise.

Out[17]:

Visualization

Line chart comparing European and American put option prices across a range of stock prices, showing the American put trading above the European put for in-the-money options. — European and American put option prices across stock prices. American puts (dashed curve) trade at a premium to European puts (solid curve) for in-the-money options ($S < K$).

Line chart showing the early exercise premium across stock prices, peaking for deep in-the-money put options. — Early exercise premium across stock prices, peaking for deep in-the-money options where the benefit of immediate exercise is greatest.

Visualizing Early Exercise RegionsLink Copied

We can examine where in the tree early exercise is optimal by using a small number of steps and visualizing the exercise boundary.

Out[18]:

Visualization

Eight-step American put lattice with labeled stock prices. Exercise nodes cluster along the lower-price branches, continuation nodes occupy the upper region, and neutral nodes form the terminal column at maturity. — Early exercise region for an American put option with $N=8$ steps. Filled exercise nodes mark states where the immediate exercise value $K-S$ exceeds the continuation value, while contrasting continuation nodes mark states where holding remains optimal. Their boundary shows the stock-price region below which the put should be exercised immediately; neutral terminal nodes represent maturity.

The early exercise boundary shows that for low stock prices (bottom of the tree), immediate exercise becomes optimal. This creates an "exercise region" below the boundary where you should exercise your puts. The boundary separates the state space into two regions: where it is optimal to continue holding the option and where it is optimal to exercise immediately.