Trading · How-to

How to read open interest: long buildup, short covering and friends

11 Oct 2026 · · TradingHow-toOptions

Open interest is the one number on an option chain that tells you what other people are doing rather than what the price is doing. Price is the result; open interest is part of the cause. Once I understood how to read the two together, the chain stopped being a wall of numbers and started being a map of where positions were being added and removed. This is the mental model behind my option chain analyser, written out in full.

This is an educational guide. Nothing here is a trading recommendation.

What open interest actually is

Open interest is the number of contracts that are currently open, meaning they have been bought by someone and sold by someone else, and neither side has closed out. It is not volume. Volume counts every trade in a day; open interest counts the positions that still exist at the end of it.

That distinction gives you a simple rule. If open interest goes up, new positions were created: a buyer and a seller who were not there before. If open interest goes down, existing positions were closed: a buyer and a seller who were there before have both left. On its own this tells you nothing about direction. For that you need the price.

The four buildup types

Combine the sign of the price change with the sign of the open interest change and you get four cells. Every contract on the chain lands in exactly one of them.

The naming can feel backwards at first, so here is the logic. "Buildup" means open interest is rising: positions are being built. Whether they are long or short positions is inferred from which way the price went while they were built. "Covering" and "liquidation" mean open interest is falling: positions are being unwound. Short covering pushes price up because shorts have to buy; long liquidation pushes price down because longs have to sell.

In code this is two sign checks, and that is genuinely all the analyser does per contract:

function classify(priceChg, oiChg) {
  const up = priceChg > 0;
  const more = oiChg > 0;
  if (up && more)   return "Long Buildup";      // bullish
  if (!up && more)  return "Short Buildup";     // bearish
  if (up && !more)  return "Short Covering";    // bullish
  return "Long Liquidation";                     // bearish
}

Calls and puts read differently

Here is the part that trips people up. The table above describes the contract itself. A long buildup in a call is bullish for the underlying, because people are buying calls. A long buildup in a put is also "bullish" for the put contract, but that means people are buying puts, which is bearish for the underlying.

So when you read a chain you have to flip the put side. The analyser keeps the raw label on each contract and then derives the market view from the combination. A simple way to hold it in your head:

• Rising call OI with rising call price: buyers want upside. Bullish.
• Rising call OI with falling call price: writers are selling calls, they expect a ceiling. Bearish, or at least capped.
• Rising put OI with rising put price: buyers want downside protection or a drop. Bearish.
• Rising put OI with falling put price: writers are selling puts, they expect a floor. Bullish, or at least supported.

Call writers and put writers are usually the larger, better capitalised side of the market, so heavy OI additions on a falling premium tend to mark levels the market is not expected to cross. That is why the strike with the highest call OI is often called resistance, and the strike with the highest put OI is called support.

Worked examples

The numbers below are illustrative, not from any particular day. What matters is the pattern.

Example 1: a clean long buildup in calls

Nifty is at 24,500. The 24,600 call closed yesterday at 80 with 1,200,000 contracts open. Today it is at 110 with 1,600,000 open. Price up, OI up: long buildup. Someone is paying more for upside and more people are doing it. On its own this reads bullish for the index.

Example 2: short covering in puts

Same day, the 24,400 put went from 70 to 95 while OI dropped from 2,000,000 to 1,500,000. Price up, OI down: short covering. Put writers who were comfortable with a floor at 24,400 are buying back their shorts. For the underlying this is bearish, because the people who were betting the index would hold above 24,400 are leaving.

Put the two examples together and you have a conflict: calls say up, puts say the floor is weakening. That is normal. The chain rarely agrees with itself, and the job is to weigh which side is bigger and which strikes are closest to the current price.

Example 3: reading a whole chain

To go from strike-level labels to one view, I sum the OI changes on each side within a few strikes of the spot and compare them. Here is the shape of that in code:

// rows: [{ strike, ce: { oiChg, priceChg }, pe: { oiChg, priceChg } }]
function marketBias(rows, spot, window = 5) {
  const near = rows
    .sort((a, b) => Math.abs(a.strike - spot) - Math.abs(b.strike - spot))
    .slice(0, window * 2);

  let callWriting = 0, putWriting = 0;
  for (const r of near) {
    // writers add OI while the premium falls
    if (r.ce.oiChg > 0 && r.ce.priceChg < 0) callWriting += r.ce.oiChg;
    if (r.pe.oiChg > 0 && r.pe.priceChg < 0) putWriting  += r.pe.oiChg;
  }
  if (putWriting > callWriting) return "bullish";  // buy calls / sell puts
  if (callWriting > putWriting) return "bearish";  // sell calls / buy puts
  return "neutral";
}

The suggested actions follow directly: a bullish read maps to buying calls or selling puts; a bearish read maps to selling calls or buying puts. The analyser prints exactly that line at the top of the page.

How to do this yourself

1. Open the option chain for your index and pick the nearest expiry. Far expiries have thin OI and the changes are noise.
2. Find the spot price and look five strikes above and below it. Ignore the rest for now.
3. For each call and put in that range, note the sign of the premium change and the sign of the OI change, and label the cell using the table above.
4. Flip the put side when thinking about the underlying.
5. Find the largest OI additions on falling premiums. Those are the writers, and their strikes are your support and resistance.
6. Compare the total put writing to the total call writing near the spot. That difference is your bias.
7. Repeat at the same time each day so the changes are comparable. The NSE numbers are deltas versus the previous close, so mid-session reads drift as the day goes on.

If you would rather not do the arithmetic by hand, option_chain_analysis fetches the Nifty chain on each visit and prints the labels for you. It has an expiry selector and can be pointed at FINNIFTY with one constant in app.js.

Things that will mislead you

• Expiry day. OI collapses across the board as contracts settle, and every cell looks like liquidation or covering. Do not read the chain on expiry day.
• Rollovers. In the last week of a monthly series, OI moves from the near month to the next month. That is not a view, it is housekeeping.
• Tiny strikes. A 300 percent OI increase on a far out-of-the-money strike with 500 contracts is not a signal.
• One snapshot. A single read tells you about one day. Trends in OI over several days are far more informative than any single cell.

What I learned

• The four-cell table is the entire framework. Everything else is about which cells to weight and which to ignore.
• Writers matter more than buyers. The largest OI additions on falling premiums tell you where the market expects price to stall.
• Conflicting signals are the norm. A tool that forces a single answer is lying; one that shows all the labels and lets you weigh them is honest.
• Reading the chain at the same time every day was the single biggest improvement to how useful it was.

Source on GitHub >