Meta description: How automated option selling actually works on Zerodha's Kite Connect API, what it can and cannot do, the real infrastructure cost, and a practical checklist before you connect live capital.

Last updated: November 11, 2026. Zerodha plan details, limits and the static IP rule were last re-read from Zerodha's own pages on November 9, 2026.

Advertisement EliteAlgo advertisement

Quick Answer

Zerodha's Kite Connect is Zerodha's API for placing, modifying and cancelling orders in your own account from code. It is not a strategy engine, not a backtester, and it has no sandbox. To run an automated option selling strategy on Zerodha you need three pieces working together: strategy logic that decides what to sell and when, execution and risk logic that sizes, hedges and exits, and the Kite Connect API that carries the order to the exchange. Zerodha supplies only the third.

Four things decide whether this is practical for you in 2026. All four are checked against Zerodha's own pages as of 9 November 2026.

  • Cost. The Personal plan is free and covers orders, GTT, alerts, margins and portfolio, but no market data. The Connect plan is Rs 500 a month per app and adds live WebSocket data and historical candles. A short-option system that watches prices for its stop-loss needs live data, so in practice most option sellers pay the Rs 500.
  • Static IP. Since 1 April 2026 every API order must come from a static IP you have whitelisted in your Kite developer account. Data streams and read-only calls are not affected.
  • Order speed cap. Staying at or under 10 orders per second per client lets you run your own algo without exchange registration. Above that, the algo needs exchange registration.
  • No hand-holding. Zerodha does not give phone or ticket support for API code, and there is no sandbox. You test with your own paper-trading layer, then with the smallest real size.

Kite Connect facts at a glance

ItemWhat Zerodha saysSource
Personal planFree. Orders, GTT, alerts, margin computation, portfolio. No live or historical dataZerodha API page
Connect planRs 500 a month per app. Adds WebSocket streaming and historical candlesZerodha support: API charges
Static IPMandatory for order placement from 1 April 2026. One primary IP, one optional secondary. One change allowed per calendar weekZerodha support: static IP
Order limits10 orders a second, 400 a minute, 5,000 a day per API key, 25 modifications per orderKite Connect docs
SandboxNoneZerodha support: sandbox
Coding supportNone by phone or ticket. Questions go to the developer forumZerodha support: coding help

This is written from the operating side of a proprietary options desk that has run intraday expiry-day option-selling strategies on NIFTY and SENSEX through the Kite Connect API in live markets, not from a marketing brief. Numbers, subscription costs, and API mechanics below reflect what we have directly verified; where something depends on Zerodha's own current policy, we say so and point you to the primary source rather than guessing.

Why Option Sellers Specifically Reach for Automation

Why option sellers automate their strategy: consistent entry timing, a disciplined stop-loss, a repeatable order sequence and trading without emotion

This page is about execution — automating a strategy you already have. For the strategies themselves, structure by structure, see option selling strategies explained.

Option selling is a strategy where the edge, if it exists, is thin, statistical, and highly sensitive to execution quality. A short strangle or an iron condor on NIFTY collects premium that decays predictably under Black-Scholes theta, but the strategy's actual profitability depends on three things a human cannot reliably do by hand, every single trading day, at scale:

  1. Consistent entry timing. A strategy that enters a short straddle at 9:20 am versus 9:35 am on a volatile morning can show meaningfully different results over hundreds of trading days, simply from IV crush timing and gap risk. Manual entry drifts.
  2. Disciplined stop-loss execution. Option sellers face theoretically unlimited loss on the short leg. A strategy's backtested edge assumes every stop-loss triggers at the defined level. A human who hesitates for even 90 seconds during a fast move can turn a defined-risk trade into an account-threatening one.
  3. Repeatable multi-leg order sequencing. A four-leg iron condor needs all four legs placed, confirmed, and reconciled correctly, every day, without fat-finger errors. At volume, this is a mechanical problem, not a judgment problem.

This is exactly the gap automation is built to close: remove timing drift and hesitation from execution while leaving strategy logic, position sizing, and risk limits under your explicit control. It is not a shortcut to finding an edge that does not already exist in your backtest.

What Kite Connect Actually Is (and Is Not)

Zerodha's Kite Connect is a REST and WebSocket trading API that gives programmatic access to the same order types, margin data, and market data available in the Kite web and mobile apps. In practical terms, Kite Connect lets a script or application:

  • Place, modify, and cancel orders. The order varieties in the current docs are regular, after-market, cover, iceberg and auction, plus separate GTT orders. Bracket orders are not in that list, so do not build on them
  • Stream live market quotes and order-book depth over WebSocket
  • Fetch positions, holdings, margins, and (on the paid plan) historical OHLC candles
  • Receive order and trade status updates via postbacks or WebSocket ticks

What Kite Connect does not provide out of the box:

  • A strategy backtesting engine
  • Pre-built option-selling strategy templates
  • Automated multi-leg order sequencing logic (you build the sequencing yourself, or a platform built on top of Kite Connect does)
  • Risk management beyond what the exchange and your broker enforce (margin calls, RMS squareoffs)

Kite Connect has two plans. Personal is free and allows order placement but gives no market data. Connect is Rs 500 a month per app, cut from Rs 2,000 on 6 May 2025 (Zerodha's own Z-Connect note explains the cut), and includes live and historical data. Historical data cannot be bought alone. You subscribe to Connect first. There is also a loyalty rebate. Zerodha's pages say paid users who generate enough brokerage in a month get 500 Developer Credits, worth Rs 500, to renew the next month. The two Zerodha pages that describe it disagree on the start month and the brokerage threshold (Rs 2,000 from October on one, Rs 500 from November on the other), so read the billing page in your own developer account before you count on it.

One more line from Zerodha's API terms is worth reading in full: the APIs "are not meant for placing fully automated trades (without manual intervention)", and full automation needs exchange approvals. Zerodha's support page on algo trading then says that staying within 10 orders per second per client lets you run without individual exchange approval, provided you use a whitelisted static IP. Read together, that is the current position: a personal algo under the 10 per second line is allowed; anything above needs registration. This is how we read it, not legal advice, and your broker's compliance team is the final word.

The Three Layers of a Real Automated Option Selling System

Three layers of a real automated option selling system shown as a pyramid: strategy logic, execution and order management, and risk and money management

Anyone evaluating "automated option selling on Zerodha" is really evaluating three separate layers, whether they realize it or not. Conflating them is where most retail traders get confused about what they are actually buying or building.

Layer 1: Strategy Logic

This is the part that decides what trade to put on, when to enter, what strikes to select, and what conditions define an exit. For intraday NIFTY or SENSEX expiry-day option selling specifically, strategy logic typically includes: If you are new to selling options, learn the manual rules first in the Nifty option selling guide for beginners, and see the short straddle explained page for the 9:20 rule-based version.

  • Entry time and entry trigger (e.g., time-based entry at a fixed minute, or a volatility/IV-based trigger)
  • Strike selection method (fixed delta, fixed premium band, or fixed points from spot/ATM)
  • Stop-loss definition per leg (points-based, percentage-based, or combined portfolio stop-loss)
  • Target definition, if any, and trailing logic
  • Re-entry rules if a leg is stopped out early

None of this lives inside Kite Connect. It lives in your own code, a strategy platform's configuration, or a spreadsheet you translate into rules. This is also the layer where a strategy's actual historical edge is proven or disproven — and it needs to be proven with realistic slippage and brokerage costs baked in, not idealized fills. Our own backtesting methodology writeup goes into why backtest quality here matters more than almost anything else in the whole stack.

Layer 2: Execution and Order Management

This layer takes the strategy's decision ("sell this strike, buy that hedge, at this size") and turns it into correctly sequenced, correctly sized orders sent through Kite Connect, with retry logic if an order gets rejected, and reconciliation logic to confirm fills match what was intended. For multi-leg option selling this matters more than it sounds:

  • If leg 1 (the short leg) fills but leg 2 (the hedge) does not, you are momentarily carrying undefined risk. Good execution logic detects this and either retries the hedge immediately or squares off leg 1.
  • Partial fills on illiquid strikes need handling logic, not silent assumption of a full fill.
  • Rate limits on the API (Kite Connect enforces request throttling) need to be respected, especially when managing several legs across multiple strategies simultaneously.

Layer 3: Risk and Money Management

This is the layer that decides how much capital and margin any single strategy or the whole account is allowed to deploy, and what happens when things go wrong at the portfolio level, not just the trade level. It includes:

  • Daily maximum loss limits that force a full system shutdown for the day if breached
  • Per-strategy capital allocation caps
  • Margin buffer monitoring, since option selling margins can expand sharply on a volatility spike, and a margin call mid-session on an automated system with no human watching is a real failure mode
  • A kill switch that a human can trigger manually at any time, regardless of what the automated logic is doing

If you are evaluating any automated option selling setup, ask directly: where does each of these three layers live, and who is responsible for it. A platform or a script that only handles Layer 2 (execution) is not a complete automated trading system on its own; it is an order-placement pipe. That distinction matters more than most marketing pages make it sound.

Building It Yourself vs Using a Platform

There are broadly two paths to running an automated option selling strategy on Kite Connect, and the right one depends on your coding capacity, capital, and how much control you want over the strategy layer.

Path A: Build directly on Kite Connect. This means writing your own Python (or other language) application using the kiteconnect Python client or the raw REST API, handling authentication (Kite Connect uses a daily token-based login flow, not a persistent API key alone), order placement, WebSocket tick handling, and your own strategy and risk logic. This gives full control and no platform fee beyond the Kite Connect plan itself (free for orders only, Rs 500 a month with market data) plus whatever it costs you to hold a static IP, usually a small cloud server or a fixed-IP broadband line. It still needs real engineering discipline: error handling, logging, reconnection logic for WebSocket drops, and a way to test without a sandbox, because Zerodha has none. This is the path we run internally for our own intraday expiry strategies, because it lets us control every part of the execution and risk layer directly rather than trusting a third-party's implementation of it.

Path B: Use a third-party algo platform that connects to Kite Connect on your behalf. Several platforms in the Indian market (AlgoTest, Tradetron, Quantman, and others) let you build or select strategies on their platform and connect your Zerodha account via the Kite Connect API for execution, without writing code yourself. This lowers the technical barrier significantly but adds a platform subscription cost (and, depending on the platform, possibly your own Kite Connect plan), and puts a layer of someone else's execution code between your strategy decision and the actual order. We compared several of these directly in our Tradetron vs AlgoTest vs Quantman breakdown if you are weighing that route, and separately in what AlgoTest plus Zerodha actually does and doesn't do. If your shortlist is a desktop execution bridge versus a cloud strategy platform, read Stoxxo vs Tradetron for option selling.

Neither path is universally correct. A trader with strong coding skills and a strategy they trust deeply often prefers Path A for full control and lower recurring cost. A trader who wants to deploy faster and is comfortable paying a platform fee for a tested execution layer often prefers Path B. What both paths share is the same underlying dependency on Kite Connect for the actual order placement, and the same requirement that the strategy logic itself be proven out of sample before real capital goes in.

Setting Up Kite Connect: What the Process Actually Involves

Setting up the Zerodha Kite Connect API in six steps around the Kite Connect logo: register as a developer, pick the plan, whitelist a static IP, implement the daily login, build against the order and WebSocket APIs, and add monitoring

For readers evaluating Path A specifically, here is what the Kite Connect setup process generally involves, at a level of detail most marketing pages skip. Confirm exact current steps on Zerodha's Kite Connect developer console, since Zerodha updates its onboarding flow periodically.

  1. Register as a developer at developers.kite.trade/signup, choose a plan, then create an app. You enter your Zerodha client ID and a redirect URL (a localhost address works while testing) and get an API key and secret. Keep the secret out of your code repository.
  2. Pick the plan. Connect is billed per app, separately from brokerage, and is a real recurring cost to weigh against the size of the strategy.
  3. Whitelist your static IP in the Profile section of the developer console. Check it twice before saving, because the exchange rules allow only one change per calendar week. If family accounts share one IP, Zerodha lets a single developer account hold separate apps for each member.
  4. Implement the login flow. Kite Connect uses a daily token-based authentication flow: you generate a request token through a login redirect, then exchange it for an access token that is valid until you log out or the session expires, typically requiring a fresh token generation each trading day. This needs to be automated in your script if you want the system to run unattended.
  5. Build against the order placement and WebSocket APIs. Zerodha has no sandbox, so your first tests are either a paper-trading layer you write (read live quotes, log the orders you would send) or one lot with real money. Do the paper stage first. Our paper trading guide for option-selling algos covers how to set that up and what it cannot tell you.
  6. Add reconciliation and monitoring so you know, in real time, whether the system is actually running, whether orders are filling as expected, and whether the account is within its risk limits — not by checking manually at day's end.

That last step is where a lot of retail automation attempts fail quietly. An automated option-selling script that runs unmonitored and silently disconnects from the WebSocket mid-session, missing a stop-loss trigger, is a genuinely dangerous failure mode specific to option selling, because the downside on a naked or under-hedged short option is not capped the way a long option's downside is.

The 2026 Rules You Cannot Skip: Static IP, 10 Orders a Second, Daily Login

The retail algo framework that SEBI announced in February 2025 and NSE detailed in its implementation circular is now live for API users. We have a separate plain-English guide to the SEBI algo rules, so here is only what touches a Kite Connect script. If you are still choosing between brokers, our broker API comparison sets Kite Connect beside Dhan, Upstox and Groww on token life, static IP rules and API cost.

  • Your own code, your own server. If you write the algo and send orders through Kite Connect yourself, the exchanges treat it as a client-generated algo. It needs a static IP mapped to your API key. Zerodha's page says this applies from 1 April 2026 to all API order placement. The WebSocket data stream, order book and positions can still be read from any IP.
  • 10 orders per second. Up to 10 orders per second per segment per exchange, the algo runs unregistered, with a generic tag on its orders. Above that it needs a registered algo ID. An intraday NIFTY strangle with a few legs and a few stop-loss modifications is nowhere near this line. A system that fires many strategies at the same minute can get close, so count orders at your busiest second, including stop-loss modifications.
  • Third-party platforms. A platform that is empanelled with the exchanges uses its own static IP, which is why you do not need one for them. Ask the platform which model it runs on before you pay.
  • Daily login stays. Kite Connect still needs the login flow each trading day, so a script that runs unattended has to handle the login and the token refresh itself, safely, with your API secret kept out of source control.
  • Family IP. One static IP can be shared by you and your immediate family (spouse, dependent children, dependent parents) through a single developer account, with Zerodha's declaration that the IP is used only by you and your family. It cannot be shared with friends or clients.

If your internet provider changes your IP, your orders stop. The practical fix is a small cloud server with a fixed address that runs the script, with the same address whitelisted in your Kite app. A home connection with a "static IP" add-on from the provider also works, but check that it really does not rotate.

Kite Connect Limits That Hit Option Sellers

These are the limits we design around. They come from the Kite Connect docs as of 9 November 2026.

LimitValueWhy it matters for a short-option system
Order placement rate10 requests a second, 400 orders a minuteA basket of legs sent in a burst, or retry loops after a rejection, can trip it
Orders per day5,000 per API key, all segmentsInvalid requests count too, so a bug that spams rejected orders eats the quota and can lock you out by afternoon
Modifications25 per orderA stop-loss that trails every tick will hit it. Cancel and re-place after that, or trail in steps
Quote endpoint1 request a secondPoll quotes for a whole option chain and you will be throttled. Use the WebSocket
Historical candles3 requests a secondMatters when you pull data for a backtest
WebSocket3,000 instruments per connection, up to 3 connections per API keyEnough for the strikes near the money on NIFTY and SENSEX, if you subscribe only to what the strategy needs

What Option Selling Needs From the API, Specifically

What an automated option selling system needs from the Kite Connect API: live market data, order placement and modification, order status checks, secure access and risk alerts

Most Kite Connect tutorials show you how to buy one share of a stock. Option selling asks different things from the same API. These are the points we would want a new builder to know before the first live day.

There is no option chain endpoint

Zerodha's developer forum answer is consistent: Kite Connect does not return an option chain. You download the instrument list, filter it by exchange and symbol, group contracts by expiry and strike, and then pull prices and open interest through the quote API or the WebSocket. That list changes every day as strikes and expiries are added, so your script must reload it each morning and never rely on a stored list. If you want to understand what to do with the chain once you have it, read what an option chain is and how sellers read it.

Market orders need market protection

For MARKET and SL-M orders the API takes a market_protection value: a custom percentage above 0 and up to 100, or -1 for automatic protection. For a short option that gaps through your stop, this is the difference between a fill at a price you accepted and a fill wherever the book happens to be. Choose it on purpose and test what your orders do in a thin strike.

Freeze limits and order slicing

Large quantity gets split by the exchange freeze limit. The API has an autoslice flag that slices for you, and it is off by default. Decide in advance whether your system slices through the API or sends its own slices, and make sure the hedge leg is sliced the same way as the short leg.

Tag every order

Orders accept an optional tag of up to 20 letters and digits. Use one tag per strategy so that when you reconcile the order book at 3:30 pm you can see which strategy owns which leg. It costs nothing and it saves hours when two strategies share a strike. For how expiry settlement works after the close, see the SEBI closing auction session and expiry settlement page.

A placed order is not a filled order

Zerodha's docs say it plainly: a successful placement response means the order reached the OMS, not that it executed. Your system needs the order status from the postback or the order history before it treats a leg as live. This is exactly the failure that leaves a hedge unfilled while the short leg is working.

Hedge first, then sell

On a margin-efficient defined-risk structure, buy the hedge before you sell the short leg. The margin benefit shows only once both legs are in the account, and an unhedged leg while the hedge is rejected is the worst moment to find out. How the margin changes with the hedge is in our SPAN and exposure margin guide for a NIFTY strangle, and our view on hedging a short strangle is in when and how we hedge.

Stop-loss placement

You can keep stop-losses inside your script (it watches the price and sends a market order) or place them with the exchange as SL orders. A script-held stop depends on your server, your internet and your WebSocket being alive at the worst moment. An exchange-held stop survives all three but has its own fill risk. Whichever you pick, test it with a dropped connection on purpose. See trailing stop-loss on short options for how trailing interacts with the 25-modification cap.

What It Really Costs to Run

ItemCostNote
Kite Connect PersonalFreeOrders only. No live data for stop-losses
Kite Connect ConnectRs 500 a month per appNeeded for WebSocket prices. Possible credit back if your brokerage qualifies (check your billing page)
Static IPYour cost depends on the providerA small cloud server or fixed-IP broadband. Get a quote; we do not quote a number here because it varies
Third-party platformPlatform subscriptionCompare in our platform guide and Streak alternatives
Brokerage, STT, slippagePer tradeThe cost that decides most strategies. It belongs in the backtest from day one

The Rs 500 is the smallest cost on the list. A strategy that makes a small edge per trade can lose all of it to slippage on stop-loss orders, which is why the backtest has to carry realistic costs. Our guide on how to backtest an option-selling strategy shows how.

Where to Learn the API

  • Official docs and the Python client. The Kite Connect docs and the pykiteconnect client are the source of truth. Older blog posts show an older login call and an older WebSocket class. QuantInsti's well-known blog on this topic still shows code from that era, so use it for the idea and the docs for the syntax.
  • Zerodha x QuantInsti course. Zerodha announced a free course on algo trading with Kite Connect in Python with QuantInsti's Quantra in November 2025, covering live and historical data, WebSockets, order types and risk management. Check Quantra for what it covers now.
  • Developer forum. The Kite Connect developer forum is where Zerodha says API questions go. Search before you post, since most first-week problems (token errors, order rejections, option chain questions) have been asked many times.
  • Python for this job. Our Python for algo trading in India page covers the language side, and the Zerodha vs Fyers vs Angel One API comparison helps if you are still choosing a broker. For the wider picture see our broker API guide.

If you do not want to code at all, YouTube is full of "automate your NIFTY options with Python" walk-throughs. Treat them as demos of the plumbing. None of them is evidence that the strategy makes money.

Risk Realities Specific to Automated Option Selling

Automation removes execution hesitation, but it does not remove the underlying risk profile of option selling. If anything, automation without proper safeguards can make risk worse, because a script does not develop a "gut feeling" that something is wrong the way a discretionary trader might. A few risk points worth being explicit about, particularly for intraday and expiry-day strategies on NIFTY and SENSEX:

  • Naked short options carry theoretically unlimited loss. Any automated system selling naked options, without a defined hedge leg, needs a hard stop-loss that is guaranteed to execute, not merely intended to. Slippage on a stop-loss during a fast move is real and should be modeled into your backtest, not assumed away.
  • Margin requirements expand during volatility spikes. SEBI and exchange-mandated margin frameworks (SPAN plus exposure margin) increase option-selling margin requirements sharply when implied volatility rises, which can trigger an automatic RMS squareoff mid-position if your account is under-capitalized for that scenario. See NSE's derivatives segment documentation for how margining works at the exchange level.
  • Weekly expiry structural changes affect strategy validity. NSE has changed weekly options expiry days and contract structures more than once in recent years; a strategy tuned to an old expiry calendar can silently misfire against the current one. Always verify your strategy's assumptions against the current NSE circular before running it live.
  • Your own bug can be the risk. Invalid orders count towards the 5,000-a-day limit, and a retry loop on a rejected hedge can burn it fast or send duplicate legs. Cap retries, and make the system stop and alert rather than keep trying.
  • IP or login failure at the open. If the static IP changes or the daily login fails, orders are refused. Test the full login-to-first-order path every morning before the entry time, with no order, and have an alert go to your phone if it fails.
  • Gap risk on entry. An automated system with a fixed entry time does not adapt to an overnight gap the way a discretionary trader glancing at the opening print might. This needs to be an explicit rule in the strategy layer (e.g., a gap filter that skips entry beyond a defined range), not an assumption.

None of this is a reason to avoid automation. It is a reason to make sure the risk layer described above is treated as seriously as the strategy layer, and tested under stress scenarios, not just average-case backtests.

Advertisement EliteAlgo advertisement

A Realistic Evaluation Checklist

Before connecting an automated option selling system, built by you or run through a platform, to live capital on Zerodha, work through this list honestly:

  • Has the strategy been backtested with realistic slippage, brokerage, and STT costs included, not idealized fills?
  • Is there a hard daily loss limit that forces a shutdown, independent of the strategy's own logic?
  • Does the system detect and alert on a dropped WebSocket connection or authentication failure, rather than failing silently?
  • Is every multi-leg strategy hedged, or is any leg naked with an unhedged, uncapped downside?
  • Have you personally verified the Kite Connect subscription cost and terms directly on Zerodha's developer console for your current usage level?
  • If using a third-party platform, have you confirmed exactly which of the three layers (strategy, execution, risk) the platform actually owns, versus what remains your responsibility?
  • Is your static IP whitelisted in the Kite developer console, and do you know who to call if your provider changes it?
  • Is the busiest second of your system under 10 orders, counting stop-loss modifications and retries?
  • Does the system confirm the status of each order before it treats a leg as live, rather than trusting the placement response?
  • Have you tested the stop-loss path with the connection cut on purpose?
  • Is there a manual kill switch you can trigger in under a minute if something looks wrong mid-session?

If any of these come back as "not sure," that is the item to resolve before scaling capital, not after.

Where EliteAlgo Fits

We build and run intraday expiry-day option-selling systems on NIFTY and SENSEX through the Kite Connect API and Zerodha infrastructure, with the strategy, execution, and risk layers described above designed and stress-tested in-house rather than assembled from a generic template. If you are evaluating whether to build this yourself, use an existing platform, or want a second opinion on a strategy's backtest before it goes live, see our related posts on choosing the best algo platform for option sellers, backtesting software that holds up to scrutiny, and building consistent monthly income from option selling. If you only want free alerts on Zerodha without writing code, see what Streak does and does not do today in our Zerodha Streak alternatives guide. If you'd rather not build or maintain the execution layer yourself, see our managed algo trading service for NIFTY and Sensex option sellers. If you are still deciding whether the whole idea suits you, start with the guide to algo trading in India and our page on NIFTY and Sensex algo trading.

This content is for educational and informational purposes. It is not investment advice, and EliteAlgo does not manage funds or guarantee returns. Options trading, particularly option selling, carries substantial risk including the potential for losses beyond initial margin. Review SEBI's investor guidance on algorithmic trading and consult a SEBI-registered investment advisor before deploying capital into any automated trading system.

Frequently Asked Questions

Does Zerodha provide a built-in automated option selling feature?

No. Zerodha's Kite app is built for manual trading. Kite Connect, its separate API product, gives programmatic order placement and market data access, but you or a third-party platform must build the strategy logic, multi-leg execution sequencing, and risk management around it. Zerodha's Streak tool can send alerts and run simple rules without code, but it is a separate product. Confirm current Kite Connect capabilities in Zerodha's developer documentation, since features are updated periodically.

Does Zerodha allow algo trading?

Yes, through Kite Connect, within limits. Zerodha's support page says that staying within 10 orders per second per client lets you automate without individual exchange approval, and you must whitelist a static IP. Above 10 orders per second, the algo needs exchange registration. Zerodha's API terms also say the APIs are not meant for fully automated trades without exchange approval, so read both pages and ask Zerodha if your case is not clear. This is how we read the rules, not legal advice.

Is automated option selling on Kite Connect legal in India?

Algorithmic trading through broker APIs is a regulated, permitted practice in India under SEBI and exchange rules. For a personal algo the main conditions now are a static IP mapped to your API key, trading only your own account (and immediate family if you share the IP), and staying under 10 orders per second unless the algo is registered. This is not a substitute for professional legal or compliance advice. See SEBI's published guidance on algorithmic trading and our guide to the SEBI algo rules for the current framework.

Is the Zerodha API free?

Partly. The Personal plan is free and covers order placement, GTT, alerts, margins and portfolio, but has no live or historical market data. The Connect plan costs Rs 500 a month per app and adds real-time WebSocket data and historical candles. Because a short-option system needs live prices to run its stop-loss, most option sellers end up on the paid plan. Zerodha also says paid users who reach a brokerage threshold can earn Developer Credits to renew, but its own pages state different thresholds, so check your billing page.

How much does it cost to run automated option selling on Zerodha's API?

If you write your own code, plan on Rs 500 a month for the Connect plan, plus whatever a static IP costs you (a small cloud server or a fixed-IP connection), plus brokerage, STT and slippage on the trades themselves. The Rs 500 was cut from Rs 2,000 on 6 May 2025. If you use a third-party platform instead, you pay that platform's subscription, so ask whether its Zerodha link runs on its own Kite Connect app or needs yours. Confirm current plans on Zerodha's developer console, since pricing has changed before.

Do I need a static IP for the Zerodha API?

For placing orders, yes. Zerodha's support page says a static IP is required for all API order placement from 1 April 2026. You whitelist it in the Profile section of your Kite Connect developer account. You can add a primary and an optional secondary IP, and the exchange rules allow only one change per calendar week. Data streams, the order book and positions can still be read from any IP.

Does Zerodha have an API sandbox for testing?

No. Zerodha says it does not offer a sandbox for Kite Connect. Builders test by writing their own paper-trading layer that reads live quotes and records the orders the strategy would send, and then go live with the smallest size. Zerodha also does not give phone or ticket support for API code; questions go to the Kite Connect developer forum.

Is there an option chain API in Kite Connect?

No. Kite Connect does not return a ready option chain. You download the daily instrument list, filter the contracts you want by symbol, expiry and strike, and then fetch prices and open interest through the quote API or the WebSocket. Reload the instrument list every morning, because strikes and expiries change.

What are the Kite Connect order limits?

Zerodha's docs list 10 order requests a second, 400 orders a minute, and 5,000 orders a day per API key across all segments. Each order can be modified at most 25 times. Invalid requests count towards the daily limit, so a bug that sends rejected orders can use it up. The quote endpoint allows 1 request a second, and one WebSocket connection can carry 3,000 instruments, with up to 3 connections per API key.

Can I backtest an option selling strategy directly inside Kite Connect?

No. Kite Connect provides historical candle data on the paid plan, which you can use to build your own backtest, but it does not include a backtesting engine or user interface. You need your own backtesting code or a third-party platform's tool for that step, and the test has to include realistic slippage, brokerage and STT.

What is the single biggest risk specific to automating option selling, versus automating a long-option or equity strategy?

Unhedged short options carry theoretically unlimited loss, and an automated system that fails to execute its stop-loss during a fast move, due to a dropped connection, an order rejection, a changed IP or extreme slippage, can turn a defined-risk trade into an uncapped one very quickly. This risk does not exist in the same form for long-option or capped-loss strategies, which is why the risk management layer deserves disproportionate attention for any automated option-selling system.

Should a beginner build their own Kite Connect integration or use an existing platform?

It depends on coding ability and how much you value full control versus faster deployment. A platform reduces the engineering burden but adds cost and puts someone else's execution code between your decision and the order. Building yourself means handling the static IP, the daily login, the order limits and the failure cases. Either way, the strategy itself needs to be proven with realistic costs before scaling capital.