This will follow on from my “Beginner Stock Options Strategies” article. The beginner options strategies aren’t too dissimilar to traditional trading strategies. If you have worked with traditional trading strategies you will be familiar with OHLCV (Open, High, Low, Close, Volume) datasets. Options datasets provide a lot more information which at first place can be quite overwhelming. What are all these additional fields? And what do they do?
Quick jump:
Options Fields Explained
Contract Identifiers:
- Date – Trading date for the option data
What it is: The trading date or data date for the option record.
Usage: Helps you track the option’s historical data and align it with market events or the underlying asset’s price changes.
- Underlying – The underlying asset (e.g. stock ticker) on which the option is based
What it is: The ticker symbol or name of the asset on which the option is based (e.g. AAPL for Apple Inc.).
Usage: Essential for mapping options data to the corresponding stock, ETF, index, or futures contract.
- Expiry – The expiration date of the option.
What it is: The date on which the option contract expires. After this date, the option can no longer be exercised.
Usage: Key for time-sensitive strategies; also factors heavily into an option’s time decay (Theta).
- Option Type – Indicates whether the option is a Call or a Put.
What it is: Indicates whether the option is a Call or a Put.
Usage: Determines the right conveyed by the option—calls give the right to buy, puts the right to sell.
- Strike – The strike price at which the option can be exercised.
What it is: The agreed-upon price at which the underlying asset can be bought (call) or sold (put) if the option is exercised.
Usage: Central to calculating an option’s intrinsic value and forms the basis of many strategies.
Price Quotes and Market Data:
- Bid – The highest price that a buyer is willing to pay for the option.
What it is: The highest price buyers in the market are currently willing to pay for the option.
Usage: Helps gauge real-time market demand and potential entry/exit prices.
- Ask – The lowest price that a seller is willing to accept for the option.
What it is: The lowest price sellers in the market are currently willing to accept for the option.
Usage: Indicates real-time supply and a typical execution cost if you want to buy immediately.
- Last – The most recent traded price of the option.
What it is: The most recent traded price of the option.
Usage: Useful for historical charts or confirming where the market last dealt.
Price Quotes and Market Data – Open, High, Low, Close, Volume (OHLCV):
What they are: Traditional price data fields used in charting. In options datasets, they can refer to the first (open), highest (high), lowest (low), and final (close) traded prices during a given session.
Usage: Helps in technical analysis, spotting price patterns, or daily price ranges.
- Open – The opening price of the option or underlying asset.
- High – The highest price reached during the session.
- Low – The lowest price reached during the session.
- Close – The closing price.
- Volume – The trading volume.
What it is: The total number of option contracts that traded hands during the day (or specified period). Usage: Indicates liquidity and market interest in that particular option series.
Interest, Volatility, and Derived Measures:
- Open Interest – The total number of outstanding option contracts that have not been settled.
What it is: The total number of outstanding (unsettled) option contracts for a given strike and expiration.
Usage: Shows how many contracts are “live” in the market and is a key indicator of liquidity and market sentiment.
- Implied Volatility – The market’s forecast of a likely movement in the underlying asset’s price.
What it is: The market’s forecast of the likely magnitude of future movements in the underlying asset’s price, derived from option prices.
Usage: Crucial for pricing options and for strategies that rely on volatility changes (e.g. straddles/strangles). Traders watch implied volatility to gauge whether options are “cheap” or “expensive.”
The Option Greeks:
These interesting fields measure an option’s sensitivity to various factors. They are partial derivatives of the option price and are vital for advanced risk management.
- Delta – Measures the rate of change of the option price with respect to changes in the underlying asset’s price.
Meaning: Sensitivity of the option’s price to a small change in the underlying asset’s price.
Usage: Helps determine how much the option’s value may move if the underlying price changes by a small amount.
- Gemma – Represents the rate of change in Delta for a change in the underlying price.
Meaning: Rate of change of Delta as the underlying asset’s price changes (i.e. how quickly Delta itself shifts).
Usage: Important for understanding the “acceleration” of an option’s price movements as the underlying moves.
- Theta – Measures the sensitivity of the option’s price to the passage of time (time decay).
Meaning: Sensitivity of the option’s price to the passage of time (time decay).
Usage: Especially important for short-term strategies and for options close to expiration. A higher Theta means the option loses value faster as time passes, all else being equal.
- Vega – Represents the sensitivity of the option’s price to changes in the volatility of the underlying asset.
Meaning: Sensitivity of the option’s price to changes in implied volatility.
Usage: Essential when volatility is expected to rise or fall, helping traders anticipate how an option’s price might change with shifting market sentiment.
- Rho – Measures the sensitivity of the option’s price to changes in interest rates.
Meaning: Sensitivity of the option’s price to changes in interest rates.
Usage: Typically less significant in short-term trading but can matter when rates fluctuate or for longer-dated options.
Gathering Data
In order to experiment with options strategies, we’ll need historical data. I’ve developed two Python scripts to retrieve and preprocess the data from the EODHD APIs endpoint. It was a little tricky as the endpoints have limits built in. What I had to do is chain requests together and then construct the dataset which I called “data/options_data.csv“. I then ran my preprocessing script to create a refined dataset called “options_data_preprocessed.csv“.
gather_data.py
import os
import csv
import requests
from dotenv import load_dotenv
load_dotenv()
api_token = os.getenv("EODHD_API_TOKEN")
def fetch_options_data_to_csv(initial_url, csv_filename):
next_url = initial_url
fieldnames = None
first_page = True
while next_url:
next_url = f"{next_url}&api_token={api_token}"
print(f"Fetching data from: {next_url}")
response = requests.get(next_url)
if response.status_code != 200:
print(f"Failed to retrieve data (HTTP {response.status_code}). Exiting.")
break
try:
json_response = response.json()
except ValueError:
print("Error decoding JSON response. Exiting.")
break
records = json_response.get("data", [])
if not records:
print("No records found on this page. Exiting loop.")
break
if first_page:
fieldnames = list(records[0].keys())
mode = "w"
first_page = False
else:
mode = "a"
with open(csv_filename, mode, newline="", encoding="utf-8") as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
if mode == "w":
writer.writeheader()
for record in records:
writer.writerow(record)
next_url = json_response.get("links", {}).get("next")
print("Data fetching completed.")
if __name__ == "__main__":
start_date = "2025-02-07"
end_date = "2025-03-23"
base_url = "https://eodhd.com/api/v2/options/AAPL.US"
initial_url = (
f"{base_url}?from={start_date}&to={end_date}"
f"&page[offset]=0&page[limit]=1000"
)
csv_file = "data/options_data.csv"
fetch_options_data_to_csv(initial_url, csv_file)preprocessing.py
import pandas as pd
def get_options_data():
return pd.read_csv("data/options_data.csv", low_memory=False)
if __name__ == "__main__":
df = get_options_data()
df_cleaned = df.dropna(subset=["tradetime"]).copy()
df_cleaned["tradetime"] = pd.to_datetime(df_cleaned["tradetime"], errors="coerce")
df_sorted = df_cleaned.sort_values(by="tradetime", ascending=True).copy()
df_sorted.reset_index(drop=True, inplace=True)
df["tradetime"] = pd.to_datetime(df["tradetime"])
df_sorted.index = df_sorted["tradetime"]
df_sorted.to_csv("data/options_data_preprocessed.csv", index=True)The preprocessed CSV dataset will look something like this…
tradetime,symbol,underlying_symbol,date,expiration_type,type,strike,exchange,currency,open,high,low,last,last_size,change,pctchange,previous,previous_date,bid,bid_date,bid_size,ask,ask_date,ask_size,moneyness,volume,volume_change,volume_pctchange,open_interest,open_interest_change,open_interest_pctchange,volatility,volatility_change,volatility_pctchange,theoretical,delta,gamma,theta,vega,rho,tradetime,vol_oi_ratio,dte,midpoint
2023-07-16,AAPL241220P00305000,AAPL,2024-12-20,monthly,put,305.0,NASDAQ,USD,0.0,0.0,0.0,111.27,0.0,0.0,0.0,0.0,,76.35,2024-10-11 19:59:56,59.0,78.15,2024-10-11 19:59:56,58,0.34,0.0,0.0,0.0,0.0,0.0,0.0,0.4771,0.0,0.0,78.15,-0.92541,0.003143,-0.033225,0.131776,-0.185405,2023-07-16,0.0,69.0,77.25
2023-07-16,AAPL241220P00305000,AAPL,2024-12-20,monthly,put,305.0,NASDAQ,USD,0.0,0.0,0.0,111.27,0.0,0.0,0.0,0.0,,79.6,2024-11-12 20:59:59,1.0,81.3,2024-11-12 20:59:59,30,0.36,0.0,0.0,0.0,0.0,0.0,0.0,0.6,0.0,0.0,81.3,-0.944012,0.00272,-0.049146,0.078716,-0.11251,2023-07-16,0.0,38.0,80.45
2023-07-16,AAPL241220P00305000,AAPL,2024-12-20,monthly,put,305.0,NASDAQ,USD,0.0,0.0,0.0,111.27,0.0,0.0,0.0,0.0,,80.55,2024-11-11 20:59:59,5.0,81.05,2024-11-11 20:59:59,59,0.36,0.0,0.0,0.0,0.0,0.0,0.0,0.498,0.0,0.0,80.8,-0.987262,0.00091,-0.009241,0.020882,-0.036663,2023-07-16,0.0,39.0,80.8The Options Greeks Strategies
In my previous article I mentioned that I was planing on writing on three advanced options strategies. As I did my own research and testing I became fascinated with some of the options specific strategies. This article will take a different approach to what I first had in mind but I think you’ll find it a lot more interesting like I have. “The Options Greeks” is very unique to options data and trading and so I will focus on some interesting strategies I found for this.
Gamma Scalping (Delta-Neutral Trading)
Core Greek Focus: Gamma (and Delta)
A trader holds an option position that has a positive Gamma (e.g. a long straddle or strangle) and frequently adjusts (or “rebalances”) the Delta to remain near zero. When the underlying price moves, Gamma causes the Delta to change, so the trader re-hedges by selling into rallies and buying into dips.
Gamma indicates how quickly Delta changes with the underlying’s price movements. By actively managing Delta, the trader can try to capture profits from price swings, effectively “scalping” the market’s intraday volatility.
This is an example of how you would generate a buy and sell signal using Python.
if 'gamma' in df.columns:
df['signal'] = df['gamma'].apply(lambda x: 1 if x > 0 else -1)
else:
df['signal'] = df['option_value'].diff().apply(lambda x: 1 if x > 0 else -1)
buy_signals = df[df['signal'] == 1]
sell_signals = df[df['signal'] == -1]Vega-Based (Volatility) Strategies
Core Greek Focus: Vega
These strategies aim to profit primarily from anticipated changes in implied volatility (IV). A long volatility approach (e.g. buying straddles) benefits if implied volatility rises, while a short volatility approach (e.g. selling strangles) profits if implied volatility remains stable or declines.
Vega measures how sensitive an option’s price is to changes in implied volatility. By closely monitoring Vega, traders can gauge the effect of rising or falling volatility on their positions.
This is an example of how you would generate a buy and sell signal using Python.
if 'vega' in df.columns:
df['signal'] = df['vega'].apply(lambda x: 1 if x > 0 else -1)
else:
df['signal'] = df['option_value'].diff().apply(lambda x: 1 if x > 0 else -1)
buy_signals = df[df['signal'] == 1]
sell_signals = df[df['signal'] == -1]Theta-Based (Time Decay) Strategies
Core Greek Focus: Theta
These strategies often aim to capitalise on time decay by collecting premium on short options, hoping they expire worthless or can be bought back cheaper. They typically involve multiple legs (e.g. selling a call spread and a put spread) to define maximum risk and keep Greeks balanced.
Theta indicates how much an option’s price erodes each day, all else being equal. Traders in these strategies frequently monitor Theta and also manage Gamma and Vega to prevent adverse moves from offsetting their time-decay gains.
Some examples include Iron Condors, Iron Butterflies, Credit Spreads, and other premium-selling approaches.
This is an example of how you would generate a buy and sell signal using Python.
if 'theta' in df.columns:
df['signal'] = df['theta'].apply(lambda x: 1 if x > 0 else -1)
else:
df['signal'] = df['option_value'].diff().apply(lambda x: 1 if x > 0 else -1)
buy_signals = df[df['signal'] == 1]
sell_signals = df[df['signal'] == -1]Rho-Sensitive Trades
Core Greek Focus: Rho
These are generally longer-term positions more exposed to interest rate fluctuations. While Rho is often minimal in short-term trades, it can matter when rates shift significantly or when holding options that are far from expiration.
Rho quantifies how much an option’s price will change if interest rates move. In a changing interest rate environment, traders may use Rho to select strategies or maturities that are less vulnerable to rate hikes or cuts.
Some examples include Long-dated options or LEAPS (Long-Term Equity Anticipation Securities).
This is an example of how you would generate a buy and sell signal using Python.
if 'rho' in df.columns:
df['signal'] = df['rho'].apply(lambda x: 1 if x > 0 else -1)
else:
df['signal'] = df['option_value'].diff().apply(lambda x: 1 if x > 0 else -1)
buy_signals = df[df['signal'] == 1]
sell_signals = df[df['signal'] == -1]Multi-Greek Risk Management (Portfolio Hedging)
Core Greek Focus: All Greeks (Delta, Gamma, Vega, Theta, Rho)
Professional traders and institutions often manage entire portfolios, not just single positions. They hedge Delta (price moves) and Gamma (accelerating risk), while also controlling exposure to Vega (volatility) and Theta (time decay).
Each Greek quantifies a different risk dimension. By monitoring a “Greek profile,” traders can adjust specific exposures (e.g. flatten Delta, reduce Vega) without closing the entire portfolio.
What Makes These Strategies “Advanced”?
This is an article on advanced options strategies after all. The Options Greeks are interesting, but what makes them advanced (in my option) …
Precision in Hedging and Positioning
Adjusting positions in response to changing Greeks demands ongoing monitoring and quick execution, especially for Gamma or Vega-driven strategies.
Multi-Faceted Risk Control
Strategies that actively manage multiple Greeks simultaneously (like delta-neutral or iron condor adjustments) can be more complex than simple directional trades.
Complex Execution and Cost
These approaches often involve multiple legs and frequent re-hedging, incurring higher transaction costs and requiring detailed trade management.
Volatility Forecasting
Vega-based strategies in particular rely on accurately predicting changes in implied volatility, which can be challenging.
Deep Market Understanding
Successfully employing Greek-focused strategies typically requires a robust understanding of market microstructure, implied volatility dynamics, and option pricing models.
In Summary
While every options strategy is influenced by the Greeks, advanced approaches such as gamma scalping, vega-based volatility trading, and theta-based premium selling specifically target or hedge particular Greeks. By structuring trades around these metrics, traders can create precise, risk-managed strategies, though they involve greater complexity and require constant oversight.
