Every option is described by how its strike sits against the stock price. That relationship, called moneyness, decides how much of the price is real value, how fast the contract reacts to the stock, and how much you lose if nothing happens. This guide compares two ends of the spectrum, deep in-the-money calls and out-of-the-money puts, and shows how to measure moneyness and delta in Mboum's options data.
Moneyness in one minute
- A call is in the money (ITM) when the stock is above the strike, and out of the money (OTM) when it is below.
- A put is the reverse: ITM when the stock is below the strike, OTM when it is above.
- At the money (ATM) means the strike is close to the stock price.
Percent moneyness measures the distance. This guide uses (stock price − strike) ÷ strike for calls and (strike − stock price) ÷ strike for puts, so a positive number is in the money and a negative number is out of the money.
Intrinsic and extrinsic value
An option's price has two parts. Intrinsic value is what it would be worth if exercised right now: stock minus strike for a call, strike minus stock for a put, never below zero. Extrinsic value is everything else, the price paid for time and volatility. Moneyness controls the split.
Worked example
These are made-up numbers for a stock called XYZ trading at $100.
Deep ITM call. The $80 call is 25% in the money by the formula above, ($100 − $80) ÷ $80, and costs $20.60.
- Intrinsic value is $20.00. Extrinsic value is $0.60, under 3% of the price.
- Delta is about 0.95, so the option moves roughly $0.95 for each $1 in XYZ. It behaves almost like owning the stock.
- It costs $2,060 per contract, against $10,000 for 100 shares. It is still a large amount at risk.
OTM put. The $90 put is about 11% out of the money, ($90 − $100) ÷ $90, and costs $0.80.
- Intrinsic value is zero. The whole $0.80 is extrinsic value.
- Delta is about −0.12. The option moves about $0.12 for each $1 move in XYZ, and gains as XYZ falls.
- It costs $80 per contract. At expiration, XYZ must be below $89.20 for the put to be worth more than you paid. If XYZ stays above $90, it expires worthless and you lose the $80.
The deep ITM call is mostly stock exposure with a thin layer of time value. The OTM put is mostly time value and is cheap because it usually expires worthless.
Reading delta from Mboum's scanner
The Unusual Options Activity page shows Strike, Stock Price and Delta for each contract. It has no moneyness column, but you can compute it from the first two. In the Nov 11, 2026 snapshot, MU traded at $813.18, and these same-day contracts were listed:
- $810 call, ITM by about 0.4%: delta 0.745
- $815 call, OTM by about 0.2%: delta 0.407
- $810 put, OTM by about 0.4%: delta −0.271
Two lessons show up. First, delta falls quickly as a call goes from in the money to out of the money. Second, at the same strike, the call and put deltas add up to about 1 when you ignore the sign. Here 0.745 + 0.271 is 1.016. A call that is ITM has a put at that strike that is OTM, and the two deltas describe the same stock exposure from opposite sides.
These were contracts expiring the same day, where delta changes fast near the strike. Longer-dated contracts move more gradually.
A checklist for choosing a side
- How much is extrinsic? Subtract intrinsic value from the midpoint. A deep ITM call with almost no extrinsic value costs about what the stock does.
- What is delta? Delta is a rough guide to stock exposure and a loose guide to the chance of finishing in the money. It is not a promise.
- How far is break-even? For a long put, break-even is the strike minus the premium. For a long call, it is the strike plus the premium.
- Is the market tight? Divide the bid-ask spread by the midpoint. Deep ITM contracts carry large premiums, so a spread that looks small in percent can still be several dollars.
- What happens if nothing moves? An OTM option loses its whole price. A deep ITM option loses only its small extrinsic part.
Get this as JSON
This script takes a ticker and an expiration, reads the quote and the chain, and prints each contract's moneyness, intrinsic value, extrinsic value, delta and spread. It uses GET https://api.mboum.com/v1/markets/stock/quotes for the stock price (docs) and GET https://api.mboum.com/v3/markets/options for the chain (docs). Each call has weight 2, so one run costs 4.
import requests
BASE = "https://api.mboum.com"
HEADERS = {"Authorization": "Bearer YOUR_MBOUM_API_KEY"}
def num(value):
return float(str(value).replace(",", "").replace("%", "").replace("+", ""))
def get(path, **params):
resp = requests.get(BASE + path, headers=HEADERS, params=params, timeout=30)
data = resp.json()
if resp.status_code != 200 or not data.get("body"):
raise SystemExit(f"{path} failed: {str(data)[:150]}")
return data["body"]
def describe(contract, spot, side):
strike, mid = num(contract["strikePrice"]), num(contract["midpoint"])
itm_amount = spot - strike if side == "Call" else strike - spot
intrinsic = max(itm_amount, 0)
spread = num(contract["askPrice"]) - num(contract["bidPrice"])
return {
"strike": strike,
"pct_itm": round(itm_amount / strike * 100, 1),
"api_moneyness": contract["moneyness"],
"mid": mid,
"intrinsic": round(intrinsic, 2),
"extrinsic": round(max(mid - intrinsic, 0), 2),
"delta": num(contract["delta"]),
"spread_pct": round(spread / mid * 100, 1) if mid else None,
}
def screen(ticker, expiration, min_itm=10, min_otm=5):
spot = num(get("/v1/markets/stock/quotes", ticker=ticker)[0]["regularMarketPrice"])
chain = get("/v3/markets/options", ticker=ticker, expiration=expiration)
calls = [describe(c, spot, "Call") for c in chain["Call"]]
puts = [describe(p, spot, "Put") for p in chain["Put"]]
deep_itm_calls = sorted((c for c in calls if c["pct_itm"] >= min_itm),
key=lambda c: c["pct_itm"])
otm_puts = sorted((p for p in puts if p["pct_itm"] <= -min_otm),
key=lambda p: p["pct_itm"], reverse=True)
print(f"{ticker} at {spot}, expiration {expiration}")
print("Deep ITM calls (nearest first):")
for row in deep_itm_calls[:3]:
print(" ", row)
print("OTM puts (closest to the money first):")
for row in otm_puts[:3]:
print(" ", row)
if __name__ == "__main__":
screen("AAPL", "2026-12-18")
The api_moneyness column is the chain's own moneyness value, so you can compare it with the calculation. In the docs example, the $590 call shows +0.19% and the put at the same strike shows −0.19%, so the field is positive when a contract is in the money.
Sample response
A trimmed call row from the docs example, with the fields the script reads:
{
"strikePrice": "590.00",
"moneyness": "+0.19%",
"bidPrice": "4.96",
"midpoint": "4.97",
"askPrice": "4.98",
"delta": "0.5518"
}
Best practices
- Check the body. A 200 response can carry an error message and no data. The script exits when
bodyis empty. - Parse the strings. Values such as
"+0.19%"and"0.5518"need cleaning before you do math. - Use a recent stock price. Intrinsic value depends on it, so a stale quote gives wrong numbers.
- Respect the rate limit. The limit is 10 requests per second, and over it returns HTTP 429. Only HTTP 200 responses count toward weight.
Next steps
Run the screen for a few tickers and expirations, and watch how extrinsic value changes as the strikes move away from the stock price. This is for education, not investment advice.
Claim your free API key and see the Mboum docs for Python, PHP, JavaScript and Bash samples.