A bracket order was a neat idea. You enter a position, and the target and the stop-loss go in with it, already attached. Nothing to remember, nothing to babysit. Then you sell NIFTY options on expiry day and try to find the button. It isn't there.

Short version, with the date on it: as of 22 November 2026, bracket orders are gone from the retail terminals that most Indian option sellers use. Cover orders survive only in narrow corners. Stop-loss-market orders are blocked on index options at Zerodha. A GTT order can protect a position, but it doesn't behave like a stop-loss at all in one important way. What an option seller can actually use is a small stack: an SL order that you treat as a market exit, a GTT as a backstop, and a stop that lives in your own code.

This post goes through each of those, what it does when things go wrong, and where the gaps are. It's written for someone who sells NIFTY or SENSEX options, or is about to start. Every broker claim below carries the date it was checked, because these pages change quietly.

Advertisement EliteAlgo advertisement

Paper trade this first. Everything here is about order mechanics and risk plumbing. It is analytical material, not investment advice, and none of it should go near live capital until you've watched it behave in a paper account through a few volatile sessions, including at least one expiry day.

What bracket and cover orders are

A bracket order (BO) is one entry order with two exit orders hanging off it: a profit target and a stop-loss. The moment the entry fills, the system places both exits. When one of them executes, the other is cancelled automatically. That "one cancels the other" link is the whole point. It is intraday only, so anything still open gets squared off before the close.

A cover order (CO) is simpler. It's an entry (market or limit) that must go in together with a stop-loss. There is no target leg. The stop is compulsory, which is where the name comes from: the position is "covered" from the first second. Because the broker knows a hard stop exists, it used to give much higher intraday leverage on cover orders than on a plain intraday order.

You can see why both were popular. A beginner who forgets to place a stop-loss is the most common source of a ruinous day, and these order types took the forgetting out of the process. The reference pages that rank for "bracket order" today, such as the guides from Arihant Plus and Bajaj Broking, mostly explain this mechanic well. What they skip is the thing an option seller needs to know: whether you can still use it, and what happens in a fast market if you do.

Why many brokers restricted them

The honest answer is that the order type looked safe and wasn't, at least during violent moves.

Take Zerodha, because its support pages are explicit. According to Zerodha's support page, bracket orders have been disabled on Kite since March 2020, and the reason given is the trouble they create when volatility rises. The mechanism is easy to see. The two exit legs sit as live orders on the exchange. In a sharp move the stop leg can trigger and execute while the target leg is still live, or the cancel of the second leg can lag behind the first fill. Now you hold an unintended position in the opposite direction, sized for a trade you've already closed. In a fast market a one-minute accident like that can cost more than the original trade ever stood to make.

The wider setting matters too. In 2020 the exchanges and SEBI were tightening intraday margin rules (the peak margin framework), and the big leverage that bracket and cover orders offered ran against that direction. Several brokers pulled or narrowed them in the same period. I'd treat the margin story as context rather than as a stated reason for every broker; only the volatility reason is written down on Zerodha's own page.

Cover orders are a mixed picture. Zerodha's Kite documentation, checked 22 November 2026, still describes a cover order as an order placed along with a stop-loss that can only be used for intraday orders in the NSE equity segment. Read that last part again. It is equity cash only. On that platform a cover order is not available on NIFTY or SENSEX options, which is the only place a weekly option seller trades. Other brokers differ, and some have dropped the product altogether. Don't rely on a third-party glossary for this; open your own broker's current order-types page and read it.

That is the single most useful habit in this whole topic. Broker support pages get edited without announcement. A statement like "broker X supports CO on options" can be true in March and false by November. If a page you rely on has no date and no version, assume it is stale until you've seen the order screen with your own eyes.

SL vs SL-M orders on options

With bracket and cover gone, the basic building block is a plain stop-loss order, and there are two of them.

  • SL (stop-loss limit): you give a trigger price and a limit price. When the trigger is hit, a limit order goes in at your limit price.
  • SL-M (stop-loss market): you give only a trigger price. When it is hit, a market order goes in.

For a seller, the difference is about as big as it gets. Say you sold a call at ₹100 and want out if it reaches ₹140. With SL-M, the exit is nearly certain to execute but at whatever price the book gives you. With SL, you set, for example, trigger ₹140 and limit ₹145. If the option jumps from ₹138 to ₹155 between two ticks, the trigger fires, your buy limit sits at ₹145, and the market is already above it. You are still short and still bleeding while a stop-loss order technically exists. That is the classic failure of SL on a fast option: the order is "working" and the risk is unprotected.

So you'd think SL-M is the answer. For index options, often it isn't available. Per Zerodha's Kite documentation, SL-M orders are blocked for index options, to limit the exposure to freak trades. On BSE, Zerodha's support page says SL-M is blocked on all instruments because the exchange discontinued the order type; that covers SENSEX options. In both cases the support pages say you can use an SL order the way you'd use SL-M. The trick is to set the limit price far enough past the trigger that it behaves like a market order, and many traders do this by adding a wide buffer.

That works, with a cost. A wide buffer means that in a calm market you may fill several rupees worse than you needed to, and in a violent market it still may not be wide enough. There is also a separate protection layer, called market protection, that brokers and exchanges apply to market-type orders; the Kite documentation lists a market_protection parameter with an automatic setting. It exists precisely because an unbounded market order on a thin option can print at an absurd price.

One more thing to keep in mind: an SL or SL-M order is not a promise from the exchange to fill you at the trigger. The trigger only tells the system when to send the order. Everything after that is just a normal order in a normal book.

GTT orders: useful, but not an intraday stop

A GTT (Good Till Triggered) order lives on the broker's side, not the exchange's. You set a trigger; when the last traded price touches it, the broker sends a real order to the exchange. On Zerodha, the support page (checked 22 November 2026) says a GTT stays active for up to 365 days, can be a single trigger or an OCO pair (a stop-loss and a target, where either one cancels the other), and supports a trailing stop-loss on both types.

Notice what that is: the "one cancels the other" behaviour of a bracket order, back again, but on the broker's server rather than the exchange's. That's the genuinely useful part.

Now the details that matter for a short option.

  • Product type. Per the same page, GTT works for CNC, NRML and MTF. Not MIS. So a GTT is built for positions you carry, not for intraday trades.
  • Time window. The page says F&O contracts trigger until 3:40 PM. After that the trigger sleeps until the next day.
  • Gaps. The page states that the GTT triggers even when the market opens beyond your trigger price. That is better than I expected, and it corrects a common assumption that a GTT will simply be skipped on a gap.
  • One shot. The trigger is valid only once. If it fires and the resulting order doesn't fill, nothing re-arms. You'd need to place a new GTT.
  • What it sends. A limit order, or a market order with market protection. Same story as above: a limit sent after a gap may sit unfilled.

So where does that leave a GTT for an option seller? It's a decent backstop for a position that must survive an overnight gap or a day your own system is offline. It is a poor primary stop on expiry day, for two reasons. First, the trigger is checked against last traded price, and thin options trade in big jumps. Second, the order that comes out is subject to the same fill risk as any SL order. Think of it as a seatbelt, not a brake.

A stop that lives in code: what an algo does instead

Once the exchange-side conveniences are gone, most serious option sellers end up doing the same thing: the stop-loss logic moves into software they control. At EliteAlgo, which is a proprietary desk trading NIFTY and SENSEX expiry-day and weekly option selling, that is the design the desk's own backtest engine assumes: the entry, the exits and the exit conditions are rules in code, and the broker is just the pipe the orders go through.

Here's why that fits an option seller better than a pre-attached stop.

  1. It can watch the right thing. A bracket stop watches the option's own price. A coded stop can watch the option price, the spot's distance from your short strike, the combined premium of a strangle, or the day's mark-to-market. For a short strangle, a stop on the combined premium is a different animal than two separate stops. (The trailing stop article linked here goes into why the trigger signal matters so much for decaying instruments.)
  2. It can exit the way you want. Convert the exit to an aggressive limit, step the price up in small increments, or slice across several orders. A fixed pre-attached order can do only what was set when the trade was entered.
  3. It knows about both legs. When one side of a strangle is stopped out, the code can decide what happens to the other: hold, tighten, or flatten. A pair of independent stops can't.
  4. It can react to a rejection. That's the part people forget, and the next section is about it.

The shape of the logic is simple. This is illustrative pseudocode for the structure, not a drop-in script for any broker:

loop every tick:
    ltp = latest_price(short_option)
    if ltp >= stop_trigger and not exit_sent:
        exit_sent = True
        send_order(buy, short_option,
                   type="SL" or "LIMIT",
                   price=ltp + buffer)        # aggressive limit, not a market order
        start_timer(reprice_after_seconds)

    if exit_sent and order_not_filled and timer_expired:
        cancel(order)
        send_order(buy, short_option, price=latest_ask + wider_buffer)

    if order_rejected(reason):
        log(reason)
        alert_human()                         # never fail silently
        fallback_exit()                       # try the next exit method

Nothing in there is clever. What makes it safe is everything around it: logging every order state, alerting when a state doesn't progress, and a fallback if the first method fails.

A coded stop has costs of its own, and pretending otherwise would be dishonest. It only works while your machine, your network and your broker session are alive. If your process crashes with a short strangle open, you have no stop at all, unless you also placed an exchange-side order or a GTT behind it. This is why the sensible design is layered. The coded stop is the primary, and the broker-side stop is the net underneath it.

SEBI's retail algo framework adds another layer to think about. According to SEBI's circular of 4 February 2025, algo orders are to be identifiable, brokers must be able to tell algo orders from non-algo orders, and a kill switch has to exist to halt a specific algorithm. The implementation date was pushed back more than once; the circular of 30 September 2025 extended the timeline further. If you run your own code against a broker API, read the current exchange standards and your broker's own rules for what needs registering. That's a compliance question I'm not going to answer for you in a blog post. Check the SEBI circular and your broker's notice.

Failure modes: freezes, gaps and rejected orders

This is the section that should change how you build things. Every exit method fails in a particular way, and the safest setup is the one where the failures don't line up.

Advertisement EliteAlgo advertisement

The gap

Price jumps past your stop between two ticks. An SL order's limit is now behind the market, and you are short with an unfilled order. An SL-M, where available, fills, but far from your trigger. A GTT fires on the open but may also hit a limit that's behind the market. A coded stop can see the gap and re-send at a wider price, but only if it was written to expect it. Rule of thumb: assume your real loss on a gap day can be a multiple of your planned stop distance, and size accordingly.

The rejected order

This one is quiet, and it hurts. An exit order can be rejected for reasons that have nothing to do with the market: an order type blocked for the instrument (the SL-M case above), a price outside the allowed range, insufficient margin to place the buy, an expired session, or a risk-check at the broker. If your code treats "order sent" as "order working", you won't notice until the position is already in trouble. Treat the order response as data. Read the status, log it, and branch on it.

The freeze limit

Exchanges cap the quantity allowed in a single order, and an order above the cap is rejected outright. If your position is large enough, a one-shot exit can bounce. Some brokers offer auto-slicing; the Kite documentation lists an autoslice parameter, for instance. The limits change by circular, so never hard-code a number in your system. Read the current figure from the exchange circular or your broker's page and make the code fetch or configure it.

The stale feed

A coded stop is only as good as its price feed. If the websocket drops and the last price stops updating, the stop never triggers because it never sees the move. Good systems track "seconds since last tick" and treat a long silence as an alarm, not as a calm market.

The dead process

Covered above: if the program dies, nothing is watching. This is exactly where a GTT or a resting exchange-side order earns its keep.

A simple way to compare them

Here's the whole picture in one table. The entries are from the checks above, dated 22 November 2026; confirm each for your own broker.

MethodLives whereMain strengthMain failure
Bracket orderExchange / brokerTarget and stop attached at entryWithdrawn on Zerodha since March 2020; double-fill risk in fast markets
Cover orderExchange / brokerCompulsory stopOn Zerodha, NSE equity intraday only; check your broker for options
SL (limit)ExchangeAvailable on optionsLimit can sit behind the market after a gap
SL-M (market)ExchangeFills almost alwaysBlocked on Zerodha for index options and on BSE
GTT (single or OCO)Broker serverSurvives overnight; triggers on gaps; OCO and trailing availableNRML not MIS; one shot; order sent may not fill
Coded stopYour systemAny logic you can writeDies if process, feed or session dies

How I'd put the layers together

Nobody should treat this as a recipe. It's a way of thinking about it, and it needs testing in a paper account before it touches money.

Start from the question each layer answers. The coded stop answers "when should I get out?" because it's the only layer that can know about the whole position. The exchange-side SL, set wide, answers "what if my system dies?" It's a disaster stop, deliberately further away than the coded one, so that it only fires if the primary has failed. A GTT, if you carry positions across days, answers "what if I can't act at the open?"

The common mistake is to place the backstop at the same level as the primary. Then both fire together, and you're sending two exit orders for one position. Keep the layers apart and make the code cancel the backstop when it completes its own exit.

Before any of it runs live, build a test setup that deliberately breaks things: kill the process mid-trade, cut the feed, send an order the broker will reject, and replay a gap day from your own historical dataset. The methodology matters more than the code. If you've never watched your system fail on purpose, you don't yet know how it fails. For a wider look at where automation itself goes wrong, see our piece on the disadvantages of algo trading, and for the broker-side wiring, the algo trading broker API guide and the Zerodha Kite API option-selling walkthrough cover the plumbing.

What to check this week

If you sell options and currently rely on an attached stop of any kind, do these five things on a paper account.

  1. Open your broker's order-types page and write down the date you read it. Look for BO, CO, SL-M and GTT, and for which segments each one covers.
  2. Place an SL order on a far-out-of-the-money option and see what the screen asks for: trigger, limit, product type. Cancel it.
  3. Try an SL-M on the index option you trade. If it's rejected, note the exact error text.
  4. Read how your code handles a rejected exit order. If the answer is "it doesn't", fix that first.
  5. Decide, in writing, what happens if your process dies with a position open.

If you'd rather have the execution layer designed and run for you, that's what our managed algo trading service is for. EliteAlgo's work is analytical software and research, not investment advice, and nothing here is a recommendation to trade any particular strike or size.

Frequently Asked Questions

What is a bracket order?

A bracket order is an intraday order that combines an entry with a profit target and a stop-loss. When the entry fills, the two exit orders are placed, and when one executes the other is cancelled. Zerodha's support page says it has had bracket orders disabled on Kite since March 2020, so availability depends entirely on your broker.

Is bracket order available for options?

On the retail platforms most sellers use, generally not. Zerodha disabled bracket orders in March 2020. Because broker pages change without notice, check your own broker's current order-types page and place a test order on a paper account before relying on any claim, including this one. This answer was checked on 22 November 2026.

What is the difference between bracket order and cover order?

A bracket order has three parts: entry, target and stop-loss. A cover order has two: entry and a compulsory stop-loss, with no target. Zerodha's Kite documentation describes its cover order as intraday and limited to the NSE equity segment, so it isn't an options tool there.

Is SL-M allowed for options?

It depends on the broker and the exchange. Zerodha's Kite documentation says SL-M orders are blocked for index options, and its support page says they are blocked on BSE instruments altogether. Both pages say a stop-loss limit (SL) order can be used in its place, with the limit price set far enough from the trigger to behave like a market exit.

What is a GTT order?

A Good Till Triggered order is held on the broker's server and sends a real order to the exchange when the price touches your trigger. On Zerodha it can last up to 365 days, supports single and OCO triggers with an optional trailing stop-loss, works for NRML positions rather than MIS, and triggers even if the market opens beyond the trigger price. It fires only once, and the order it sends can still fail to fill.

How do algo traders place stop-losses?

Most keep the main stop in their own code so it can watch the whole position, then place a wider exchange-side or GTT stop as a backstop in case the program, feed or session fails. Good setups also log every order response and raise an alert on any rejection. Paper trade the whole arrangement, including deliberate failures, before using live capital.