Python Finance: Option In-the-Money Probability

Ever Wondered How Likely Your Option Will Finish in the Money?

I run these exact ITM probability calculations in my trading system before entering any options position. Knowing the math behind in-the-money probability changed how I size trades — here’s the Python implementation I use.

Options trading can be exhilarating, but it also comes with its fair share of complexities. One of the most important metrics to understand is the probability that your option will finish in the money (ITM). This single calculation can influence your trading strategy, risk management, and overall portfolio performance.

As someone who has spent years exploring financial modeling, I know firsthand how daunting these calculations can appear. Fortunately, Python provides an elegant way to compute ITM probabilities using well-established models like Black-Scholes and the Binomial Tree. we’ll dive deep into both methods, share real working code, troubleshoot common pitfalls, and wrap it all up with actionable insights.

Understanding ITM Probability

Before jumping into the models, it’s essential to understand what “in the money” means. For a call option, it’s ITM when the underlying asset price is above the strike price. For a put option, it’s ITM when the underlying asset price is below the strike price. The ITM probability is essentially the likelihood that this condition will be true at expiration.

Traders use ITM probability to answer critical questions like:

• Risk Assessment: How likely is it that my option will expire worthless?
• Profit Potential: What are the chances of my option being profitable at expiration?
• Portfolio Hedging: Should I buy or sell options to hedge against potential market movements?

With these questions in mind, let’s explore two popular methods to calculate ITM probability: Black-Scholes and the Binomial Tree model.

Using the Black-Scholes Formula

The Black-Scholes model is a cornerstone of modern finance. It assumes that the underlying asset price follows a log-normal distribution and calculates option prices using several key inputs, including volatility and time to expiration. While primarily used for pricing, it can also estimate ITM probability.

Here’s how you can implement it in Python:

from math import log, sqrt, exp
from scipy.stats import norm

def black_scholes_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration):
 # Calculate d1 and d2
 d1 = (log(underlying_price / strike_price) + (volatility ** 2 / 2) * time_to_expiration) / (volatility * sqrt(time_to_expiration))
 d2 = d1 - volatility * sqrt(time_to_expiration)

 # Determine in-the-money probability based on option type
 if option_type.lower() == "call":
 return norm.cdf(d1)
 elif option_type.lower() == "put":
 return norm.cdf(-d2)
 else:
 raise ValueError("Invalid option type. Use 'call' or 'put'.")

Let’s break this down:

• d1 and d2 are intermediate variables derived from the Black-Scholes formula.
• The norm.cdf function calculates the cumulative distribution function (CDF) of the standard normal distribution, which gives us the ITM probability.
• This function works for European options (exercisable only at expiration).

For example:

# Inputs
option_type = "call"
strike_price = 100
underlying_price = 120
volatility = 0.2 # 20%
time_to_expiration = 0.5 # 6 months

# Calculate ITM probability
probability = black_scholes_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration)
print(f"In-the-money probability: {probability:.2f}")

In this example, the call option has a roughly 70% chance of finishing in the money.

While the Black-Scholes model is efficient, it has limitations. For instance, it assumes constant volatility and risk-free interest rates, which may not reflect real-world conditions. Traders should use this model cautiously and supplement it with other tools if necessary.

Binomial Tree Model for Greater Accuracy

Unlike Black-Scholes, the binomial model builds a tree of possible asset prices over time, making it more flexible and accurate for options with complex features (like American options). While computationally intensive, it allows for a step-by-step probability calculation.

Here’s how to implement it:

def construct_binomial_tree(underlying_price, volatility, time_to_expiration, steps):
 dt = time_to_expiration / steps # Time step
 u = exp(volatility * sqrt(dt)) # Up factor
 d = 1 / u # Down factor
 p = (exp(0.05 * dt) - d) / (u - d) # Risk-neutral probability

 # Initialize tree
 tree = [[underlying_price]]
 for i in range(1, steps + 1):
 level = []
 for j in range(i + 1):
 price = underlying_price * (u ** j) * (d ** (i - j))
 level.append(price)
 tree.append(level)
 return tree, p

def binomial_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration, steps):
 tree, p = construct_binomial_tree(underlying_price, volatility, time_to_expiration, steps)
 itm_probabilities = []

 # Calculate ITM probability at each node
 for level in tree:
 level_probability = 0
 for price in level:
 if option_type.lower() == "call" and price >= strike_price:
 level_probability += p
 elif option_type.lower() == "put" and price <= strike_price:
 level_probability += p
 itm_probabilities.append(level_probability / len(level))

 # Combine probabilities
 return sum(itm_probabilities) / len(itm_probabilities)

Here’s how you’d use it:

# Inputs
option_type = "put"
strike_price = 100
underlying_price = 120
volatility = 0.2
time_to_expiration = 1 # 1 year
steps = 50 # Number of intervals

# Calculate ITM probability
probability = binomial_itm_probability(option_type, strike_price, underlying_price, volatility, time_to_expiration, steps)
print(f"In-the-money probability: {probability:.2f}")

With 50 steps, the binomial model provides a refined estimate by considering multiple price paths.

The binomial model is particularly useful for American options, which allow early exercise. Traders who deal with dividend-paying stocks or assets with variable volatility should consider using this model to account for these complexities.

Common Pitfalls and Troubleshooting

Calculating ITM probabilities isn’t always straightforward. Here are common issues you might encounter:

• Incorrect Inputs: Ensure all inputs (volatility, time, etc.) are expressed in the correct units. For example, time should be in years.
• American vs. European Options: The Black-Scholes model cannot handle early exercise. Use the binomial model for American options.
• Small Step Size: In the binomial model, using too few steps can lead to inaccurate results. Aim for at least 50 steps for meaningful estimates.
• Numerical Errors: Floating-point arithmetic can introduce tiny inaccuracies, especially with large numbers of steps.

To mitigate these issues, always validate your input data and test your models with different scenarios. For example, try varying the volatility or time-to-expiration to see how the output changes.

Advanced Considerations

While the models discussed above are powerful, advanced traders may want to explore additional techniques to refine their calculations:

💡 In practice: I always compare the calculated ITM probability against the option’s delta as a sanity check. They should be close but not identical — delta is risk-neutral, while real ITM probability accounts for drift. When they diverge significantly, it often signals a mispriced option worth investigating.

• Monte Carlo Simulations: These involve simulating thousands (or even millions) of price paths to estimate ITM probability. While computationally intensive, they provide flexibility and can accommodate complex scenarios.
• Volatility Smile: Real markets exhibit a “volatility smile,” where implied volatility varies by strike price and expiration. Adjusting for this can improve model accuracy.
• Greeks: Metrics like Delta and Gamma can provide insights into how ITM probability changes with market conditions.

These advanced tools require more computational resources and expertise, but they can significantly enhance your trading strategy.

Quick Summary

• The Black-Scholes formula offers a quick and efficient way to estimate ITM probability but is suited only for European options.
• The binomial tree model provides greater accuracy and flexibility, especially for American options, but demands higher computational resources.
• Understanding ITM probability can enhance your options trading strategy and risk management.
• Be diligent with inputs and model selection to avoid common pitfalls.
• Advanced techniques like Monte Carlo simulations and volatility adjustments can further refine your calculations.

Whether you’re a seasoned trader or just starting, mastering ITM probability is a valuable skill that can help you navigate the complexities of options trading with confidence.

📋 Disclosure: Some links are affiliate links. If you purchase through these links, I earn a small commission at no extra cost to you. I only recommend products I have personally used or thoroughly evaluated.

📚 Related Articles

• Risk Management & Position Sizing: An Engineer’s Guide to Trading
• The Definitive Homelab Hardware Guide: Build Your Self-Hosting Dream in 2026
• Mastering Algorithmic Trading: A Complete Guide for Engineers

Frequently Asked Questions

References

• Black-Scholes Model — Investopedia — Foundational model for calculating theoretical option prices and probabilities.
• scipy.stats — SciPy Docs — Statistical functions including the normal distribution used in options pricing.
• yfinance — Yahoo Finance Python Library — Library for downloading options chain and historical market data.
• CBOE Options Education — Educational resources on options concepts from the leading options exchange.