How Dem Dey Calculate Implied Volatility

Implied volatility na something wey dem calculate by iteration, e no get direct formula. No closed-form expression fit turn option market price back into volatility number. So solver go first guess one volatility, price the option with Black-Scholes, compare the model price with the quoted price, then repeat am until both prices agree down to the last cent. Wetin follow na the complete method: the pricing function, the search loop for standard-library Python, and why two vendors fit publish different numbers for the same contract.

Why implied volatility no get closed form formula

Black-Scholes dey work for one direction. Give am spot price, strike, time to expiry, interest rate and volatility, e go return theoretical price. Five out of these six quantities dey observable. Volatility no dey. Na assumption about how far the stock go move between now and expiry.

Traders dey reverse the problem. Price dey for screen, and volatility na the unknown. Implied volatility na the volatility input wey make Black-Scholes price equal the option market price. Sigma, wey be the volatility term, dey inside the normal distribution function two times, for both d1 and d2, and no algebraic rearrangement fit isolate am. Algebra stop for there. Numerical search come take over. Wetin implied volatility dey measure dey explain the interpretation; this page dey explain the machinery.

Two properties of the model dey make the search easy. Call model price dey rise anytime volatility rise, with no exception, and e dey move smoothly. Quantity wey only dey climb fit be located by squeezing bracket around am.

Solver dey run once for each contract

The output na one number for each contract, no be one for each stock. Contracts for the same stock and the same expiry window fit give different answers. Here be every Apple (AAPL) option wey get 20 to 45 days remaining and trade on June 30, 2026, grouped by strike as fraction of the share price:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

As you read the strike ladder, 0.80-0.90 zone solve to 35.5%, 0.95-1.00 zone solve to 28.1%, and 1.10-1.20 zone solve to 27.3%. One company, one session, 6 answers. The bend for that curve get name, volatility skew, and one volatility for each stock no fit draw am.

The Black-Scholes price wey the solver need match

S na the share price, K na the strike, T na the time to expiry for years, r na the risk free rate, and N() na the standard normal cumulative distribution. E mean say na the probability say standard normal draw go land below one given point. Python carry that last part for math.erf, so the interpreter alone don do the work.

apt-get update && apt-get install -y python3

Put sudo before both commands if you dey use machine wey you no be root. Then save this as iv.py:

import math

def norm_cdf(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs_call(S, K, T, r, sigma):
    if T <= 0.0 or sigma <= 0.0:
        return max(S - K, 0.0)
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    d2 = d1 - sigma * math.sqrt(T)
    return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)

Na the complete forward model be this. Give am volatility, e go give you price.

How dem dey calculate implied volatility, step by step

Bisection na the first method wey you suppose learn. E no fit diverge, and e no need calculus.

1. Put the answer between 0.01 (1% for one year) and 5.0 (500%). Every traded option dey inside this range.
2. Price the option for the midpoint of the range.
3. If model price pass the market quote, the guess too high: move the top of the range down to the midpoint. If e dey below, move the bottom up.
4. Stop once model price dey within one cent of the quote.

def implied_vol(price, S, K, T, r, lo=0.01, hi=5.0, tol=0.01):
    for _ in range(100):
        mid = 0.5 * (lo + hi)
        diff = bs_call(S, K, T, r, mid) - price
        if abs(diff) < tol:
            return mid
        if diff > 0.0:
            hi = mid
        else:
            lo = mid
    return 0.5 * (lo + hi)

# $100 stock, $100 strike, three months, 4% rates, $5.00 on the screen
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

Run python3 iv.py. E go print about 0.226, meaning implied volatility near 22.6% for one year based on that hypothetical quote. Each pass dey cut the range into half. So, if range wey wide 4.99 get halved twenty times, e go become narrower than 0.00001. Na why the 100-iteration limit no go ever bind.

Why Newton-Raphson dey converge faster, and where e dey fail

Bisection dey throw away information wey model already get. Vega na the option price change for each unit of volatility, and Black-Scholes dey give am in closed form. Newton-Raphson dey treat am like slope: e measure pricing error, divide am by vega, then move the guess by that amount.

def bs_vega(S, K, T, r, sigma):
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    return S * math.sqrt(T) * math.exp(-0.5 * d1 * d1) / math.sqrt(2.0 * math.pi)

def implied_vol_newton(price, S, K, T, r, sigma=0.5):
    for _ in range(20):
        v = bs_vega(S, K, T, r, sigma)
        if v < 1e-8:
            return None          # no slope left, hand the job back to bisection
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # the step overshot into nonsense
        if abs(step) < 1e-6:
            return sigma
    return None

Near the money, e dey reach result for three or four passes, compared with about dozen for bisection. The problem dey inside the denominator: vega dey reduce as strike move far from share price. Na the same AAPL contracts, with each zone average vega shown as percentage of the at the money reading:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness,
     (
         SELECT avg(toFloat64(vega))
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND days_to_expiry BETWEEN 20 AND 45
           AND iv_converged = 1
           AND volume > 0
           AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
     ) AS atm_vega
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(vega)) / atm_vega, 1) AS vega_pct_of_atm,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

The wings get only small part of the sensitivity: 33.1% of the at the money vega for the 0.80-0.90 zone, and 31.6% for the 1.10-1.20 zone. If you divide pricing error by number wey small reach like that, e go produce very big step. That fit push the guess below zero, where the model no get anything left to talk. Production solvers dey combine the two methods: dem first bracket the answer, then polish am with Newton. Vega explain the greek itself.

Why two sources dey report different implied volatility

The model dey public and the arithmetic don settle, so the disagreement dey come from the inputs.

• Mid versus last. The solver need one price. Contract wey get $2.00 bid and $2.20 offer get $2.10 midpoint, while the last print fit be $2.02 from ninety minutes ago. For contract like that, ten cents for price worth pass one point of volatility.
• Dividends and carry. The function above dey price European call for stock wey no dey pay anything. Dividend before expiry dey reduce the forward price, and each desk dey use its own adjustment and rate.
• American early exercise. US single stock options fit exercise any day, and that right get value wey the European formula no get where to put. Solver wey ignore am go push the difference enter volatility. Binomial trees dey price the exercise right directly.
• Stale quotes. Strike wey last trade on Tuesday still fit show quote, and the solver dey treat anything wey dem give am as truth.

Convergence dey make the last two clear. The panel below take eight household names on June 30, 2026, count contracts wey trade with 20 to 45 days remaining, and report both the at the money volatility and the share of contracts where the solve converge:

WITH abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS distance_from_spot
SELECT underlying_symbol AS symbol,
       round(100 * avgIf(toFloat64(implied_volatility), iv_converged = 1 AND distance_from_spot < 0.05), 1) AS atm_iv_pct,
       round(100 * countIf(iv_converged = 1) / count(), 1) AS solved_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE date = toDate('2026-06-30')
  AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMZN', 'TSLA', 'SPY', 'KO', 'JNJ')
  AND days_to_expiry BETWEEN 20 AND 45
  AND volume > 0
GROUP BY symbol
HAVING countIf(iv_converged = 1 AND distance_from_spot < 0.05) > 0
ORDER BY atm_iv_pct DESC

TSLA carry the highest at the money reading among the 8 names at 47.7%, against 14.4% for SPY wey dey bottom. For the TSLA chain, 97.8% of traded contracts produce answer wey converge. The rest na strikes where the price wey dem give the solver dey outside wetin any volatility fit reproduce, quote below intrinsic value or crossed market. Whether number like that high na separate question: 30% IV high? dey explain am, and the expected move dey convert am to dollar range.

The same contract, dem solve am again every session

Nothing about implied volatility dey store. Dem dey calculate am again from any price wey dey show for screen. Below na the AAPL contract wey trade pass, and wey expire July 17, 2026. We follow am from June 1 reach expiry. The strike no move and the expiry no move:

WITH (
         SELECT ticker
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND expiration_date = toDate('2026-07-17')
           AND iv_converged = 1
           AND volume > 0
         ORDER BY volume DESC
         LIMIT 1
     ) AS pinned_contract
SELECT date,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       round(avg(days_to_expiry)) AS days_to_expiry
FROM global_markets.options_greeks
WHERE ticker = pinned_contract
  AND date BETWEEN toDate('2026-06-01') AND toDate('2026-07-17')
  AND iv_converged = 1
  AND volume > 0
GROUP BY date
ORDER BY date

Across 29 sessions, the solved reading open at 25.1% with 46 days to run, and e finish at 26.6% with 4 days remaining. Every point for that line na one run of the loop above against that session quote. Our per ticker pages publish the same solve: AAPL implied volatility dey run am daily across the whole chain, so reader fit reproduce any figure there with the code for this page.

Implied volatility calculation FAQ

Implied volatility get formula?

No. Black-Scholes dey map volatility to price, but that mapping no get simple inverse because sigma dey inside normal distribution two times. Every implied volatility number wey you see here or anywhere else come from iterative solver.

How many iterations calculation dey take?

Each bisection pass dey halve the bracket. So, range from 0.01 to 5.0 go shrink below 0.00001 after twenty passes. To match quote to the nearest cent, calculation normally need about a dozen passes. Newton-Raphson fit reach answer in three or four passes when e near the money, but some steps fit misbehave where vega small.

Why broker and data vendor dey show different implied volatility?

Na because dem give solver different inputs. Common differences na mid quote versus last trade, the rate and dividend assumption, plus whether model dey handle American early exercise at all. For thin strike, stale quote alone fit shift the answer by several points.

Calls and puts for the same strike dey give the same implied volatility?

For theory, yes. Put-call parity link dem together at the same strike and expiry. But for practice, dem set the two quotes separately. So the solved numbers fit differ small, and na another reason chain-wide averages dey vary between vendors.

I fit calculate implied volatility without market data?

Yes, for hypothetical quote. The code above dey take price, strike, spot, time to expiry and rate, all of dem typed by hand. To match live vendor number na the harder part. You need use the same inputs wey the vendor use.

Every panel for here dey store the SQL wey dey power am. Open one, then run the same solve against live chain for the Strasmore terminal.