Black-76 & the Greeks

An option's price is one of the strangest numbers in finance: it's the price of uncertainty itself. A model that turns a forward price, a strike, some time, and a volatility into that fair value is the crown jewel of derivatives theory. You've heard of Black-Scholes. But for Indian markets, the right tool is its close cousin, Black-76 - and using the wrong one is a mistake that quietly corrupts every Greek you compute. Let's price an option properly, the way Indian F&O actually works.

Black-76, not Black-Scholes

Here is the distinction most courses skip. Black-Scholes prices an option off the spot price of the underlying, carrying it forward with an interest rate. Black-76 prices it off the forward directly. They share the same DNA, but the input differs - and for Indian index and stock options, which settle against the futures/forward (Chapter 19), the forward is the correct underlying. Feed Black-76 the synthetic future we built last chapter and the model fits the market it's actually pricing.

What the model needs

Black-76 takes five inputs and returns a fair price: the forward, the strike, the time to expiry, the interest rate, and the volatility. Four of those you can read straight off the market. The fifth - volatility - is the one you can't observe, and that single fact shapes the entire options world. Because everything else is known, the model can be run backwards: given the option's market price, solve for the volatility that makes the model match. That number is the implied volatility (IV) - the market's own forecast of future volatility, and the true language options traders speak.

The Greeks: how an option breathes

Price is just the start. The Greeks are the sensitivities - how the option's value reacts to each thing that can change. Let's pull them for an at-the-money Nifty call, computed with Black-76:

# Black-76 Greeks on a Nifty option - the numbers that say how it breathes.
import os

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

# OpenAlgo computes Greeks with Black-76, priced off the synthetic-future FORWARD.
g = client.optiongreeks(symbol="NIFTY30JUN2624000CE", exchange="NFO", interest_rate=0.0,
                        underlying_symbol="NIFTY", underlying_exchange="NSE_INDEX")
gk = g["greeks"]

print(f"Option : {g['symbol']}   price {g['option_price']}")
print(f"Forward: {g['spot_price']:.2f}  (the synthetic future)   IV: {g['implied_volatility']}%\n")
print(f"  Delta  {gk['delta']:+.3f}   moves this much per 1 point of the forward")
print(f"  Gamma  {gk['gamma']:.5f}   how fast delta itself changes")
print(f"  Vega   {gk['vega']:+.2f}    gained per +1% in implied volatility")
print(f"  Theta  {gk['theta']:+.2f}   lost every day to time decay")
print(f"  Rho    {gk['rho']:+.3f}")
print("\nThese are Black-76 Greeks - the correct model for Indian F&O, priced off the forward (not spot).")

Option : NIFTY30JUN2624000CE   price 166.75
Forward: 24058.30  (the synthetic future)   IV: 11.14%

  Delta  +0.571   moves this much per 1 point of the forward
  Gamma  0.00115   how fast delta itself changes
  Vega   +11.99    gained per +1% in implied volatility
  Theta  -11.36   lost every day to time decay
  Rho    -0.027

These are Black-76 Greeks - the correct model for Indian F&O, priced off the forward (not spot).

Read the numbers from the example against the cards. Delta ≈ 0.57: the call gains about 0.57 points for each point the forward rises. Gamma: delta isn't fixed - it speeds up as the option goes in the money. Vega ≈ 12: the option gains about ₹12 for every 1% rise in implied volatility - this is your exposure to fear. Theta ≈ −11: it bleeds about ₹11 a day just from time passing - the rent an option buyer pays. Together they tell you exactly how this position will react to the market, the clock, and the mood.

Delta across strikes

Delta isn't a single number - it sweeps across strikes in a characteristic S-shape. Compute it for a whole row of Nifty calls and watch:

Copy

# The delta curve: how an option's delta sweeps from 0 to 1 across strikes.
import os
import time
from pathlib import Path

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

rows = []
for strike in range(23400, 24701, 100):
    r = client.optiongreeks(symbol=f"NIFTY30JUN26{strike}CE", exchange="NFO", interest_rate=0.0,
                            underlying_symbol="NIFTY", underlying_exchange="NSE_INDEX")
    g = r.get("greeks") or {}
    if g.get("delta") is not None:
        rows.append({"strike": strike, "delta": g["delta"], "gamma": g["gamma"]})
    time.sleep(0.3)

df = pd.DataFrame(rows)
forward = 24058

sns.set_theme(style="whitegrid")
fig, ax1 = plt.subplots(figsize=(8, 4.5))
ax1.plot(df["strike"], df["delta"], color="#7c83ff", lw=2, marker="o", ms=4, label="Delta (call)")
ax1.axvline(forward, color="#888", ls="--", lw=1.2, label="forward ~24058")
ax1.set_xlabel("Strike")
ax1.set_ylabel("Delta", color="#7c83ff")

ax2 = ax1.twinx()
ax2.plot(df["strike"], df["gamma"], color="#16a34a", lw=1.6, label="Gamma")
ax2.set_ylabel("Gamma", color="#16a34a")
ax2.grid(False)

ax1.set_title("Nifty call Greeks across strikes - delta S-curve, gamma peaks at the money")
ax1.legend(loc="center left")
out = Path(__file__).with_suffix(".png")
plt.savefig(out, dpi=110, bbox_inches="tight")
print(f"Delta runs {df['delta'].max():.2f} (deep ITM) -> {df['delta'].min():.2f} (far OTM). Saved {out.name}")

Live output

Delta runs 0.93 (deep ITM) -> 0.04 (far OTM). Saved 02_delta_curve.png

The delta curve runs from near 1 for deep in-the-money calls (they behave just like the future) down to near 0 for far out-of-the-money ones (barely sensitive), passing through about 0.5 at the money. And the green gamma line peaks right at the money - which is why at-the-money options are the most "alive," their delta flipping fastest as the market moves. This single chart is the mental map every options trader carries.

Why "wrong but useful"

A confession the textbooks bury: Black-76 is wrong. It assumes constant volatility and normally-distributed returns - and Chapter 11 proved markets have neither (fat tails, clustering vol). So why is it the foundation of a trillion-rupee industry? Because it's the common language. Nobody believes the model is literally true; they use it to convert a messy market price into one clean, comparable number - implied volatility - and to compute Greeks for hedging. The model is a translator, not a truth. Its "failure" - the fact that real IV isn't constant across strikes - is itself the most traded signal in options, and it's exactly where we go next.

Try it yourself

• Pull the Greeks for the at-the-money put (...24000PE). Is its delta negative, around −0.43, as put-call parity demands?
• Compare theta for a near-expiry option versus a far-month one. Which bleeds faster per day, and why does decay accelerate into expiry?
• Track vega across strikes. Where is an option most sensitive to a change in implied volatility - and does that match where gamma peaks?

Recap

• Indian F&O is priced with Black-76 (off the forward), not Black-Scholes (off spot) - using the wrong one corrupts every Greek.
• The model needs forward, strike, time, rate and volatility; run backwards from a market price it yields implied volatility - the market's volatility forecast.
• The Greeks are sensitivities: delta (direction), gamma (how fast delta changes), vega (sensitivity to IV), theta (time decay).
• Delta sweeps an S-curve from 0 to 1 across strikes (~0.5 at the money), and gamma peaks at the money - making ATM options the most reactive.
• Black-76 is "wrong but useful" - a constant-vol model in a fat-tailed world, used as a common language (IV) rather than literal truth.

The model assumes one volatility, but the market quotes a different implied volatility at every strike. That pattern - the volatility surface - and India's own fear gauge, India VIX, are where options trading gets genuinely interesting.