Why Option Premium per Day Can Favor Short Expirations
Summary
The note evaluates a proposed way to choose an expiration for uncovered puts: maximize option premium divided by days to expiration. It argues that this ratio tends to mechanically favor shorter-dated contracts, because option value generally does not rise in proportion to added time. A basic Black–Scholes–Merton illustration and quoted market examples show the ratio declining for a longer maturity, though these examples do not establish that the metric is a sound measure of trade quality.
The answer also notes that implied volatility often varies by maturity, which affects relative premiums, and that the simple model omits early exercise considerations for deep in-the-money puts when interest rates are positive. A subsequent contribution provides a script that selects the expiration with the highest estimated midpoint premium per day after a commission adjustment. That tool depends on available quote data and its metric does not account for assignment risk, capital usage, volatility exposure, or the seller’s broader valuation and risk constraints.
Key ideas
- Premium divided by days to expiration can systematically favor shorter maturities.
- Option value need not grow proportionally with time to expiration.
- Term structure in implied volatility changes comparisons across expirations.
- A simple Black–Scholes–Merton example omits early exercise effects for some puts.
- A premium-per-day screen does not capture the full risk and capital profile of put selling.
Tags
Full text
# Best tool to find an optimal option?
# Best tool to find an optimal option?
I like to sell uncovered put options, using my valuation of the company as the strike price. I'm looking for a tool that takes stock identifier and strike price as input and outputs the optimal expiration date, i.e. one that has the highest ratio of option price to days until expiration. Can anybody suggest anything?
## Answer by AKdemy (score 3)
https://quant.stackexchange.com/a/75168
This makes little sense. An option with the same strike, does not get much more expensive if you add a day to expiration. However, if you divide by the number of days, you reduce the value of the option significantly every day....
Example in Python (using standard Black Scholes Merton, thus ignoring that deep ITM puts, in the presence of positive interest rates $r>0$, can be subject to early exercise):
```
import numpy as np
from scipy.stats import norm
def BSM(S,K,r,d,t, sigma, cp_flag):
d1 = ((np.log(S/K) + (r - d + 0.5 * sigma **2) * t) / (sigma * np.sqrt (t)))
d2 = d1 - sigma * np.sqrt(t)
opt = cp_flag*S *np.exp(-d*t)* norm.cdf(cp_flag*d1) - cp_flag* K * np.exp(-r*t) * norm.cdf(cp_flag*d2)
return opt
pd.DataFrame(zip([i for i in range(1,365)], [BSM(100,100,0,0,i/365, 0.3, -1) for i in range(1,365)], [BSM(100,100,0,0,i/365, 0.3, -1)/i for i in range(1,365)]), columns=['Days','Put Value', 'Put/Days'])
```
This simple example even ignores that IV is usually flattening with increased maturity (which will make the longer tenors comparatively cheaper). For example, the 165 strike Apple put option expiring on 14th of April (8 days as of the last available price) costs ~ USD 2.1 at the time of writing: $2.1/8 = 0.2625$. The one expiring on 18th of August (134 days) costs ~ USD 10. $10/134 = 0.0746$.
## Answer by jgeoirgnlsfnv (score 2)
https://quant.stackexchange.com/a/75264
For anyone else wanting to achieve the same thing, here's a custom tool I've created:
```
import yfinance as yf
import numpy as np
from datetime import datetime
def read_input_file(file_name):
with open(file_name, 'r') as file:
lines = file.readlines()
return [tuple(line.strip().split()) for line in lines]
def calculate_best_expiration(ticker, strike_price, commission):
ticker_data = yf.Ticker(ticker)
expirations = ticker_data.options
prices_per_day = []
for expiration in expirations:
data = ticker_data.option_chain(date=expiration).puts
data = data[data['lastTradeDate'].notnull()]
data = data[data['strike'] == float(strike_price)]
days_to_expiration = (datetime.fromisoformat(expiration) - datetime.today()).days
if len(data) > 0 and days_to_expiration > 0:
ask = data['ask'].iloc[0]
bid = data['bid'].iloc[0]
price = (bid + ask) / 2 * 100 - commission
prices_per_day.append(price / days_to_expiration)
else:
prices_per_day.append(np.nan)
best_expiration_index = int(np.nanargmax(prices_per_day))
return expirations[best_expiration_index], prices_per_day[best_expiration_index]
if __name__ == '__main__':
input_data = read_input_file('input.txt')
commission = 2.1 # flat fee per contract in USD
for ticker, strike_price in input_data:
try:
(best_expiration, ratio) = calculate_best_expiration(ticker, strike_price, commission)
print(f'{ticker} ({strike_price}): {best_expiration}, USD ${ratio:.3f}/day/contract')
except Exception as e:
print(f'Error while processing {ticker} ({strike_price}): {e}')
```
The expected input file format is:
```
AAPL 100
INTC 25
...
```Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.