Options traders print money in volatile markets.

And unless you’ve been sleeping over the last three months, you’ve noticed the elevated levels of volatility.

The way these traders make money is not taking directional bets, but trading volatility. One way they do it is by taking advantage of the volatility skew. The volatility skew is the different in implied volatility across a range of strike prices.

In today’s newsletter, you’ll get Python code to build volatility skew for call and put options.

Let’s go!

How smart traders use options skew to maximize profits

Options skew, or volatility skew, illustrates the disparity in implied volatility across options strike prices. This phenomenon influences trading decisions, risk evaluations, and profit potential in options trading.

In practice, options skew demonstrates a curve from in-the-money to out-of-the-money options. Various elements, such as market sentiment and hedging strategies, can shape this curve. Traders leverage skew to find mispriced options, allowing them to optimize profit and manage risk.

Professionals use options skew to refine trading strategies, adapt to market volatility, and improve profitability.

They focus on its impact on option prices to adjust hedging strategies or identify trading opportunities. Observing skew helps them predict market movements, enhancing their trading edge.

Let's see how it works with Python.

Imports and set up

These libraries help us fetch stock data, analyze options, and visualize results.

1import numpy as np
2import pandas as pd
3import yfinance as yf
4from matplotlib import pyplot as plt

We'll start by getting the options chain for Palantir Technologies (PLTR) with an expiration date of July 18, 2025.

1ticker = "PLTR"
2stock = yf.Ticker(ticker)
3options_chain = stock.option_chain("2025-07-18")
4
5calls = options_chain.calls
6puts = options_chain.puts

We use the yfinance library to fetch option data for PLTR. We create a Ticker object for PLTR and request its option chain for the specified date. The data is split into two DataFrames: one for call options and another for put options.

Clean and process option data

Now we'll define functions to clean our data and build an implied volatility grid.

1def clean(df):
2    cols = ["strike", "impliedVolatility"]
3    return (
4        df[cols]
5        .dropna(subset=["impliedVolatility"])
6        .drop_duplicates("strike")
7        .astype({"strike": float, "impliedVolatility": float})
8        .sort_values("strike")
9        .set_index("strike")
10    )
11
12
13def build_iv_grid(df):
14    df_iv = clean(df)
15    strike_grid = np.arange(df_iv.index.min(), df_iv.index.max() + 1, 1.0)
16    return (
17        df_iv.reindex(strike_grid)
18        .interpolate(method="linear")
19        .rename_axis("strike")
20        .reset_index()
21    )

We define two functions: clean and build_iv_grid. The clean function filters and formats our data, keeping only the strike price and implied volatility columns. The build_iv_grid function creates a uniform grid of strike prices and interpolates the implied volatility values. This helps us create a smooth volatility curve.

Plot volatility skew for calls and puts

Finally, we'll create and plot the volatility skew for both call and put options.

1call_skew = build_iv_grid(calls)
2plt.plot(call_skew.strike, call_skew.impliedVolatility)

The result is a chart that looks like this.

‍

And for the put options.

1put_skew = build_iv_grid(puts)
2plt.plot(put_skew.strike, put_skew.impliedVolatility)

The steeply downward-sloping curve shows that lower-strike calls carry markedly higher implied volatility than higher-strike calls—a classic “left-tail” volatility smirk.

This implies the market assigns elevated probability mass to sharp downside moves and that investors are paying a premium for insurance-like convexity at low strikes.

Professional option desks exploit this mispricing by running skew trades to harvest the volatility differential as it compresses.

The result is a chart that looks like this.

We apply our build_iv_grid function to both the call and put options data. This gives us a smooth curve of implied volatilities across different strike prices. We then plot these curves using matplotlib. The resulting graph shows the volatility skew for both call and put options, allowing us to visualize how implied volatility changes with the strike price.

Professionals monetize the rich left-tail skew by systematically selling the high-IV, deep-out-of-the-money puts and hedging with offsetting long nearer-the-money puts or dynamic delta-hedges, capturing the downside volatility premium as it mean-reverts.

Your next steps

yFinance is great for market data, including options. Experiment with different underlying stocks or different expirations. See how the skew changes based on the expiration of the option.