DEV Community

shakti tiwari
shakti tiwari

Posted on

Option Chain Analysis Nifty: PCR, Max Pain, IV Skew & Live Data (2026)

#nifty #options #trading #india

Option Chain Analysis Nifty

If you want to trade Nifty options with an edge, you have to stop guessing and start reading what the market itself is telling you. That is exactly what Option Chain Analysis Nifty gives you. The option chain is a live ledger of every strike's open interest, volume, premium, implied volatility, and the buy/sell pressure behind it. Read it correctly and you see where institutions are hedging, where support and resistance really sit, and when a breakout is building.

In this guide we cover the five pillars of option chain analysis — PCR (Put-Call Ratio), Max Pain, IV skew, OI buildup — plus a live NSE data fetch in Python, how to actually read the chain on Zerodha Kite or Dhan, and the concrete trading signals you can act on. Language is Hinglish-friendly so even if you are new to derivatives, aap samajh jaayenge.

What Is the Nifty Option Chain?

The Nifty option chain is a table, usually sorted by strike price, showing all available call (CE) and put (PE) contracts for a given expiry. On NSE's website or your broker's platform, each row contains:

  • Strike Price — the level at which the option can be exercised.
  • Open Interest (OI) — total outstanding contracts not yet squared off.
  • Change in OI — fresh money flowing in or out.
  • Volume — contracts traded that day.
  • IV (Implied Volatility) — the market's expectation of future volatility, priced into the premium.
  • LTP (Last Traded Price) — current premium.
  • Bid/Ask & Delta — liquidity and directional sensitivity.

For Nifty, strikes are spaced ₹50 apart near the spot (e.g., 23,950, 24,000, 24,050). NSE lists weekly and monthly expiries, and the chain is updated in near real-time during market hours (9:15 AM – 3:30 PM IST).

Pillar 1: PCR (Put-Call Ratio)

PCR = Total Put OI ÷ Total Call OI for the expiry.

  • PCR > 1 → more puts than calls open → market may be oversold / bearishly positioned → potential contrarian bullish reversal.
  • PCR < 0.7 → heavy call buildup → possibly overbought → caution for longs.
  • PCR near 1.3–1.5 often marks extreme fear; historically these zones preceded recoveries.

But raw PCR can mislead. A better version is PCR based on volume or the change in PCR. Also compare today's PCR to its 5-day average. A rising PCR while Nifty falls = panic hedging, often a bottoming signal.

Python: Compute PCR from NSE Data

We will fetch live NSE option chain data. NSE requires a browser-like User-Agent and a cookie handshake. Below is a robust snippet.

#!/usr/bin/env python3
"""Fetch Nifty option chain from NSE and compute PCR.
Run on Mac/Linux/Termux: python3 nifty_pcr.py
Windows CMD: py nifty_pcr.py
"""
import json
import urllib.request

NSE_CHAIN_URL = "https://www.nseindia.com/api/option-chain-indices?symbol=NIFTY"

HEADERS = {
    "User-Agent": ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                   "AppleWebKit/537.36 (KHTML, like Gecko) "
                   "Chrome/120.0 Safari/537.36"),
    "Accept": "application/json",
    "Referer": "https://www.nseindia.com/option-chain",
}

def fetch_chain():
    req = urllib.request.Request(NSE_CHAIN_URL, headers=HEADERS)
    # First hit to get cookies
    with urllib.request.urlopen(req, timeout=10) as r:
        data = json.loads(r.read().decode())
    return data

def compute_pcr(data):
    records = data["records"]["data"]
    put_oi = call_oi = 0
    for rec in records:
        if rec.get("CE"):
            call_oi += rec["CE"].get("openInterest", 0) or 0
        if rec.get("PE"):
            put_oi += rec["PE"].get("openInterest", 0) or 0
    pcr = put_oi / call_oi if call_oi else 0
    return put_oi, call_oi, round(pcr, 3)

if __name__ == "__main__":
    try:
        data = fetch_chain()
        expiry = data["records"]["expiryDates"][0]
        put_oi, call_oi, pcr = compute_pcr(data)
        print(f"Expiry: {expiry}")
        print(f"Total Call OI: {call_oi:,}")
        print(f"Total Put OI : {put_oi:,}")
        print(f"PCR          : {pcr}")
        if pcr > 1.3:
            print("Interpretation: High PCR -> possible oversold / contrarian long setup")
        elif pcr < 0.7:
            print("Interpretation: Low PCR -> call-heavy, caution on longs")
        else:
            print("Interpretation: Neutral PCR")
    except Exception as e:
        print("Fetch failed:", e)
        print("Tip: NSE may block. Use requests with session + cookies, or a broker API (Dhan/Zerodha).")
Enter fullscreen mode Exit fullscreen mode

If NSE blocks the direct call, the reliable fix is a requests.Session() that visits the homepage first to grab cookies, or use the Dhan/Zerodha market data APIs (covered in our trading system articles).

Pillar 2: Max Pain

Max Pain is the strike at which the maximum number of option buyers (both calls and puts) lose the most money at expiry. Option writers (who are usually smarter, better capitalized) tend to steer the underlying toward max pain to expire options worthless.

Computation: for each strike, sum the loss to option holders if spot expires there, then pick the strike with the lowest total pain.

def max_pain(records):
    strikes = sorted({r["strikePrice"] for r in records})
    pain_map = {}
    for s in strikes:
        total_pain = 0
        for r in records:
            ce = r.get("CE")
            pe = r.get("PE")
            if ce:
                oi = ce.get("openInterest", 0) or 0
                # call holders lose if spot < strike
                if s < r["strikePrice"]:
                    total_pain += oi * (r["strikePrice"] - s)
            if pe:
                oi = pe.get("openInterest", 0) or 0
                # put holders lose if spot > strike
                if s > r["strikePrice"]:
                    total_pain += oi * (s - r["strikePrice"])
        pain_map[s] = total_pain
    return min(pain_map, key=pain_map.get)

# usage inside __main__ after fetching data:
# mp = max_pain(data["records"]["data"])
# print("Max Pain strike:", mp)
Enter fullscreen mode Exit fullscreen mode

Trading use: If Nifty is far above max pain near expiry, there is a gravitational pull downward toward max pain; if far below, upward pull. It is not a guarantee but a strong tendential force, especially on expiry Thursday.

Pillar 3: IV Skew

Implied Volatility (IV) is what the market expects for future swings. The IV skew is the pattern of IV across strikes:

  • Normal/skew-down (calls cheaper IV than puts): typical in Indian indices — puts cost more vol-wise because everyone buys downside protection.
  • Reverse skew / smirk: deep OTM puts show very high IV (fear hedging).
  • Flat skew: calm market.

A steep put skew = fear premium; a rising call skew = greed/upside speculation. Watch IV skew to avoid buying overpriced options. If you buy a call when its IV is already 30 and it drops to 20 (IV crush), your option can lose money even if Nifty moves your way — that is vega risk.

On Zerodha Kite, IV is shown per strike. On Dhan, the option chain also displays IV%. Compare ATM IV across expiries to gauge term structure (near-term vs far-term vol).

Pillar 4: OI Buildup

Open Interest buildup reveals where the real positioning is:

  • Call OI building + price rising → call writers getting trapped → bullish.
  • Call OI building + price falling → call writers comfortable → resistance forming.
  • Put OI building + price falling → put writers trapped → bearish.
  • Put OI building + price rising → put writers safe → support forming.

The highest put OI strike is usually strong support; the highest call OI strike is usually strong resistance. This creates the famous "range-bound between max call OI and max put OI" setup that dominates non-event days on Nifty.

Spotting a Breakout

When Nifty approaches a major call OI strike and call OI starts dropping while price pushes through, it means call writers are covering — a genuine breakout signal. Similarly, put OI unwinding below support signals breakdown. This "OI unwinding leading price" is one of the most reliable intraday tells.

How to Read the Chain on Zerodha / Dhan

  1. Open Nifty option chain (Kite: Search → Nifty → Option Chain; Dhan: Derivatives → Nifty).
  2. Find ATM strike (closest to spot).
  3. Look left/right for max call OI (resistance) and max put OI (support).
  4. Check PCR at top (some platforms show it; otherwise compute via our script).
  5. Note IV on ATM — above 20 is elevated for Nifty, below 12 is calm.
  6. Watch change in OI during the day for fresh positioning.

Trading Signals from Option Chain Analysis Nifty

Combine the pillars for higher-probability setups:

Signal What You See Suggested Read
Range play High call OI above, high put OI below, low PCR change Sell strangles/iron flies (advanced) or avoid directionals
Breakout Price pierces call OI, call OI unwinds Buy calls / go long futures
Breakdown Price breaks put OI support, put OI unwinds Buy puts / go short
Reversal PCR > 1.4 and Nifty near support Contrarian long
Vol expansion IV skew steepens intraday Expect a big move; size smaller

Live NSE Data Fetch: Full Script

Here is a more complete fetch that writes the chain to CSV for analysis in pandas.

#!/usr/bin/env python3
"""Download Nifty option chain to CSV for analysis."""
import csv
import json
import urllib.request

URL = "https://www.nseindia.com/api/option-chain-indices?symbol=NIFTY"
HEADERS = {
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36",
    "Accept": "application/json",
    "Referer": "https://www.nseindia.com/option-chain",
}

def download_csv(path="nifty_chain.csv"):
    req = urllib.request.Request(URL, headers=HEADERS)
    with urllib.request.urlopen(req, timeout=10) as r:
        data = json.loads(r.read().decode())
    rows = []
    for rec in data["records"]["data"]:
        strike = rec["strikePrice"]
        ce = rec.get("CE") or {}
        pe = rec.get("PE") or {}
        rows.append({
            "strike": strike,
            "ce_oi": ce.get("openInterest", 0),
            "ce_iv": ce.get("impliedVolatility", 0),
            "ce_ltp": ce.get("lastPrice", 0),
            "pe_oi": pe.get("openInterest", 0),
            "pe_iv": pe.get("impliedVolatility", 0),
            "pe_ltp": pe.get("lastPrice", 0),
        })
    with open(path, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=rows[0].keys())
        w.writeheader()
        w.writerows(rows)
    print(f"Saved {len(rows)} strikes to {path}")

if __name__ == "__main__":
    download_csv()
Enter fullscreen mode Exit fullscreen mode

Run it:

# Mac / Linux / Termux
python3 nifty_chain_csv.py

# Windows CMD
py nifty_chain_csv.py
Enter fullscreen mode Exit fullscreen mode

Then load in pandas to compute PCR, max pain, or plot OI:

import pandas as pd
df = pd.read_csv("nifty_chain.csv")
print(df.head())
print("Max Call OI strike:", df.loc[df['ce_oi'].idxmax(), 'strike'])
print("Max Put OI strike :", df.loc[df['pe_oi'].idxmax(), 'strike'])
Enter fullscreen mode Exit fullscreen mode

Realistic Indian Market Context

On a typical pre-budget or RBI policy day, Nifty IV can spike from 14 to 22+, and PCR swings wildly. During the 2024–2025 period, Nifty ranged between roughly 21,000 and 25,000, and weekly expiry days consistently showed max pain acting as a magnet. SEBI's increased margin requirements and the shift to SEBI's new F&O rules (effective 2024–25) — including higher contract sizes and the T+0 settlement pilots — mean retail traders must rely even more on data-driven reading rather than tips.

Zerodha's Kite and Dhan both surface OI and IV, but neither computes max pain for you automatically — that is why the Python snippets above are gold. Build them once, schedule a cron on your Termux/Android or a Linux VPS, and you have a daily option-chain intelligence report.

Common Pitfalls in Option Chain Reading

  1. Trusting stale OI — OI from yesterday is not today's battle. Watch change-in-OI.
  2. Ignoring events — before results/RBI/US CPI, IV skew dominates; chain reads differently.
  3. Single-metric trading — PCR alone is not a trade. Combine with price and OI flow.
  4. Forgetting expiry — max pain is strongest on expiry day, weak mid-week.

Frequently Asked Questions

Q1. What is the best PCR value for Nifty trading?
There is no single "best," but PCR above 1.3 with Nifty near support often flags oversold/contrarian long setups, while PCR below 0.7 with Nifty near resistance flags caution. Always compare to the 5-day average, not an absolute number.

Q2. How accurate is Max Pain?
Max pain is a tendential magnet, not a law. It works best on expiry Thursday when option writers dominate. Mid-week it is a weaker guide. Treat it as one input, not the whole thesis.

Q3. Can I get NSE option chain data for free via Python?
Yes — NSE publishes an option-chain API. Use a session with proper headers/cookies (see scripts). For reliability at scale, brokers like Dhan and Zerodha offer official market-data APIs with better uptime.

Q4. What IV is considered high for Nifty?
Nifty ATM IV around 12–16 is normal; above 20 is elevated (event/panic); below 10 is very calm. High IV makes buying expensive and selling attractive (if you manage directional risk).

Q5. Which is better — Zerodha or Dhan for chain analysis?
Both show OI, IV, and volume well. Dhan has a cleaner TradingView integration and an API-friendly approach; Zerodha Kite is battle-tested. For automation, Dhan's API plus Python (as shown) is very convenient.

Final Words

Option Chain Analysis Nifty turns the chaotic ticker into a structured map: PCR shows sentiment, max pain shows the gravitational target, IV skew shows fear/greed pricing, and OI buildup shows where the smart money is positioned. Learn to read these four together and you trade with the market's own footprints instead of against them. Pair it with the Python scripts, run them daily, and let data — not tips — guide your Nifty trades.

Shakti Tiwari is a Nifty option trader and AI builder at optiontradingwithai.in. Find more at dev.to/@shaktitiwari715-ai.

Top comments (0)