Best Broker for TradingView Automation in India (2026): Zerodha vs Dhan vs Angel One vs Fyers vs Upstox

If you want to fire a TradingView alert and have it place a live order on an Indian exchange, the single biggest decision you make is the broker. Picking the best broker for TradingView automation in India is not about who has the lowest brokerage or the prettiest app, it is about how the broker exposes orders to a webhook, what the API costs, and how much plumbing you have to build and maintain after the new SEBI rules kicked in on 1 April 2026.

This is a neutral, no-affiliate comparison. I build these bridges for clients on all five of these brokers, so I have no incentive to push one over another. What follows is how Zerodha, Dhan, Angel One, Fyers and Upstox actually behave when you point a TradingView alert at them in 2026, and a clear recommendation by use-case at the end.

The two ways TradingView talks to an Indian broker

Before the table, you need to understand the two fundamentally different architectures, because they decide how much work (and risk) sits on your side.

1. Native broker integration / native webhook order type. The broker itself accepts the TradingView signal. Either you connect your account inside TradingView's trading panel and trade from the chart, or the broker gives you a webhook URL plus a JSON template that you paste straight into a TradingView alert. No server, no code, no token refresh on your side. In India, Dhan is the standout here.
2. Self-hosted webhook bridge to the broker's REST API. TradingView can only POST a webhook to one public HTTPS URL per alert. It cannot authenticate, retry intelligently, or transform a payload. So you run a small server (a VPS, a cloud function, a Flask/FastAPI app) that receives the alert, validates it, logs in to the broker API, and places the order. This is how Zerodha, Angel One, Fyers and Upstox automation generally works.

Most people underestimate option 2. The bridge is where deduplication, session management, position checks, market-hours guards and error handling live. A naked "alert hits broker" setup is exactly how people fire ten orders off one candle or send a buy into a halted session. I cover that architecture in depth in the ultimate guide to TradingView webhooks for Angel One and Zerodha.

The one rule that now applies to all of them: static IP

SEBI's retail algo trading framework (circular dated 4 February 2025) became mandatory on 1 April 2026. The part that affects every broker on this list equally: any order placed through a broker API must originate from a static IP that you have whitelisted with the broker. Orders from an unregistered or dynamic IP are simply rejected. This applies regardless of how few orders you send.

That single rule kills the "deploy my bot on free Heroku/Railway/Render" plan, because those platforms hand out dynamic egress IPs. You now need a VPS with a fixed IP, a cloud static IP, or a static-egress proxy. It also means the comparison below is less about "does this broker need a static IP" (they all do for API orders) and more about who carries that burden for you. The two brokers with native, broker-side TradingView order handling (Dhan, and Zerodha's own Trade-From-Charts) shift that IP burden onto the broker's infrastructure, not yours.

Rules and pricing change. Treat the figures here as current-2026 ranges and verify the live details on the broker's developer console before you build.

Broker-by-broker comparison table

Here is the head-to-head on the things that actually matter for TradingView automation. "Bridge" means you self-host a server; "Native" means the broker accepts the signal directly.

Factor	Zerodha (Kite Connect)	Dhan	Angel One (SmartAPI)	Fyers (API v3)	Upstox (API v3)
API order cost	Free for personal use (orders only); ~Rs 500/mo per key to add live + historical data	Free (webhook order type bundled with account)	Free	Free	Free
Native TradingView path	Yes — Trade-From-Charts inside Kite, plus connect-in-TradingView panel; API for full automation	Yes — native broker integration on TradingView and a native webhook order type with JSON	No — bridge required	No — bridge required (or third-party API bridge)	No — bridge required
True hands-off webhook (no server)	Partial (manual click on TFC; full auto needs API + bridge)	Yes	No	No	No
Static-IP burden on you	Yes for API orders	No (handled broker-side for native webhook)	Yes	Yes	Yes
Auth model	OAuth login, daily session; clean SDK	Webhook secret in JSON (native) / token for API	OAuth + daily TOTP 2FA; pyotp for headless login	OAuth v3, daily session; fast SDK	OAuth 2.0, daily token; Analytics Token (1-yr) for read-only via static IP
Latency / execution	Mature, reliable; well-documented	Low — built for TV order flow	Good; solid Python SDK	Fast — sub-50ms orders, 1 lakh req/day (v3)	Good; v3 added kill-switch, fund/margin v3
Options support	Full (NFO, equity, futures)	Full incl. multi-leg via webhook JSON	Full	Full	Full
Best for	Serious custom algos, data needs, reliability	No-code / low-code TradingView traders	Budget Python automation, large user base	Low-latency / high-throughput strategies	OAuth-comfortable devs, read-heavy analytics

Zerodha (Kite Connect): the reliable default for custom algos

Zerodha overhauled Kite Connect in 2025. The trading API is now free for personal use for placing orders and tracking positions, holdings and funds. The catch: the free personal tier does not include market data. If your strategy needs live quotes or historical candles from the broker, you move to the paid Connect plan at roughly Rs 500/month per API key, which now bundles both live and historical data (the old separate historical-data fee was dropped).

For TradingView specifically, Zerodha gives you two flavours. Trade-From-Charts (TFC) embeds TradingView charts inside Kite and lets you place orders from the chart with a click — great for discretionary trading, not fully automated. For genuine unattended automation you use Kite Connect via a webhook bridge: TradingView alert to your server to Kite order. The SDK is the cleanest in the market and the documentation is the best, which is why it is my default recommendation when a client wants a robust custom system. Remember the static-IP whitelist on your developer console, and note the strict 10 orders-per-second cap (anything above 10 OPS needs a registered strategy with the exchange). If you are weighing the data cost and the enctoken alternatives, my guide to automating Kite Connect with Python walks through it, and the full bridge build is in the Zerodha webhook integration setup.

Dhan: the easiest path if you do not want to run a server

Dhan is the genuinely different one. It was India's first native TradingView trading integration, and it offers a webhook as a native order type. You generate a webhook URL inside Dhan, pick your instrument, click "Generate JSON", and paste that JSON into your TradingView alert. The broker handles authentication and order placement. There is no server to run, no daily token to refresh, and the static-IP burden sits on Dhan's side, not yours.

It supports equity, futures, options and multi-segment / multi-leg strategies through the JSON template. For a trader who has a working Pine strategy and just wants it to fire live orders without writing or hosting any code, Dhan is the lowest-friction option in India right now. The one operational gotcha: the webhook URL is mapped to the secret inside your JSON, so whenever you regenerate or rotate a webhook URL you must update the JSON in every TradingView alert that uses it, and watch the validity/expiry. If a no-code route appeals, see how to automate TradingView alerts without any code.

Angel One (SmartAPI): free, popular, but TOTP-heavy

Angel One's SmartAPI is free and backed by one of the largest retail user bases in India, so there is a lot of community code around it. There is no native TradingView order type — you build a bridge (commonly a Python Flask/FastAPI app using the official smartapi-python library) that receives the alert and places the order.

The defining quirk is authentication. SmartAPI uses mandatory TOTP 2FA. For a headless, always-on bot you generate the TOTP programmatically with pyotp using your 32-character secret, so the login looks like this:

from SmartApi import SmartConnect
import pyotp

api_key   = "YOUR_API_KEY"
client_id = "YOUR_CLIENT_CODE"
pin       = "YOUR_PIN"
totp_seed = "YOUR_32_CHAR_TOTP_SECRET"

obj  = SmartConnect(api_key=api_key)
totp = pyotp.TOTP(totp_seed).now()
session = obj.generateSession(client_id, pin, totp)
# session token is valid until midnight; re-login each trading day

Sessions expire at midnight, so your bridge must re-authenticate daily. That is fine for a properly built server but it is one more thing to get right. Angel One is a strong budget pick for someone comfortable in Python who wants a free API and does not mind the bridge. For the overall picture of going live in India, the algo trading in India 2026 overview is a good companion read.

Fyers (API v3): the low-latency choice

Fyers keeps the trading API free and the v3 release is built for speed: order execution in under ~50ms and a rate limit raised to around 1 lakh requests/day (a 10x jump over the old limit). SDKs cover REST, Python, Node.js, JavaScript and .NET/C#. There is no native TradingView order type, so you either self-host a bridge to the API or use a third-party API bridge product (which may carry its own fee).

If your edge is in throughput or you are running multiple symbols and want the tightest execution loop, Fyers is the broker I reach for. The static-IP rule applies as it does everywhere, and Fyers has published the post-1-April-2026 app-activation and family static-IP steps in its knowledge base, so the compliance path is well documented. Just keep your strategy under 10 OPS unless you have an exchange-registered strategy ID.

Upstox (API v3): solid, but mind the daily OAuth dance

Upstox v3 is free and capable, with recent additions like a Kill Switch API (programmatically halt a segment), a more detailed Fund and Margin v3 endpoint, and dedicated static-IP management endpoints (GET/PUT /user/ip) that went live in April 2026. There is no native TradingView order type, so it is a bridge like the others.

The friction point is OAuth. The standard trading access token must be regenerated every day — the classic Upstox daily-login pain. Upstox softened this for read-only use with an Analytics Token (one-time generation, 1-year validity) that unlocks market data and read-only portfolio/positions via a registered static IP, but that token does not place orders. So for live execution you still automate the daily OAuth refresh in your bridge. Upstox is a fine pick if you are comfortable scripting that flow; if daily re-auth annoys you, Dhan (native) or Fyers (clean v3 session) feel smoother.

So which is the best broker for TradingView automation in India?

There is no single winner — there is a winner per use-case. Here is how I actually advise clients:

• You want it working today with zero coding/hosting: Dhan. Native webhook order type, no server, no daily token, broker carries the static IP. The fastest path from "my Pine strategy works" to "it places live orders".
• You want a serious, reliable custom algo and may need data: Zerodha. Best SDK, best docs, free orders, ~Rs 500/mo if you need live + historical data. You will run a bridge and a static IP, but it is the sturdiest foundation.
• You want free API automation on a budget and live in Python: Angel One. Free, huge community, just accept the daily TOTP re-login in your bridge.
• You care about latency or high throughput: Fyers. Sub-50ms orders, generous rate limits, clean v3 session model.
• You already use Upstox and are comfortable with OAuth: Upstox v3, with the daily token refresh automated and the Analytics Token for read-heavy analytics.

One honest caveat that cuts across all five: the broker is maybe 30% of a reliable automated system. The other 70% is the bridge — deduplication, session handling, market-hours and circuit guards, lot-size and risk checks, logging, and alerting when something fails silently. A clean Pine alert payload matters too; if your JSON is sloppy your orders will be too, which is why I always start from well-formed alertcondition JSON payloads. And if you are still deciding whether to build this yourself or hire it out, the honest cost guide for 2026 lays out the trade-offs.

A quick word on legality and capital

Automated execution of your own strategies on your own account, below 10 OPS, through a compliant broker API with a whitelisted static IP, is permitted under the 2026 framework. Selling signals or running a black-box service for others is a different regulatory animal (Research Analyst registration, principal-agent rules). If you are unsure where you stand, read is algo trading legal in India and size your account sensibly using how much capital you need for algo trading in India before you go live. Regulations evolve — verify the current SEBI/exchange position before trading real money.

Want the bridge built right the first time?

Choosing the broker is the easy part. The reliable, non-repainting, static-IP-compliant bridge between your TradingView alert and live orders is where most DIY setups quietly break. I build and maintain exactly these systems for traders in India, the UK and the US. If you want a webhook bridge done properly on Zerodha, Dhan, Angel One, Fyers or Upstox, see my TradingView automation development service or just get in touch and tell me your broker and strategy.

FAQ

Which is the best broker for TradingView automation in India in 2026?

It depends on your use-case. Dhan is best for no-code, server-free automation because it offers a native TradingView webhook order type. Zerodha is best for serious custom algos thanks to its clean Kite Connect SDK and documentation. Fyers wins on latency, Angel One on free Python-friendly access, and Upstox suits developers comfortable with daily OAuth. All require a whitelisted static IP for API order placement.

Do I need a static IP for TradingView-to-broker automation now?

Yes, for any order placed through a broker API. Under SEBI's retail algo framework mandatory from 1 April 2026, orders must originate from a static IP you have whitelisted with the broker; dynamic IPs are rejected. This rules out free dynamic-IP cloud hosts like Heroku or Railway. Brokers with native broker-side webhook handling (notably Dhan) carry that IP burden for you. Rules change — verify current details with your broker.

Is the broker API free for TradingView automation?

For placing orders, Dhan, Angel One, Fyers and Upstox APIs are effectively free, and Zerodha's personal API is free for orders only. Live and historical market data is where costs appear: Zerodha's paid Connect plan is around Rs 500/month per key for data. Third-party API bridges and static-IP proxy services may add their own fees. Verify current pricing on each broker's developer console.

Can TradingView place orders directly without any code?

With Dhan, yes — you paste the broker-generated JSON into a TradingView alert and orders fire natively. Zerodha's Trade-From-Charts lets you click to trade from the chart but is not fully unattended. For Angel One, Fyers and Upstox you need a self-hosted webhook bridge that authenticates and places the order, which requires code or a third-party bridge tool.

Why do I need a webhook bridge instead of pointing TradingView straight at the broker?

A TradingView alert can only POST to one public URL and cannot authenticate, deduplicate, retry, or check account state. A bridge sits between the alert and the broker to validate the signal, manage the broker session, block duplicate or out-of-hours orders, enforce risk and lot-size rules, and log everything. Skipping it is the most common cause of duplicate fills and orders sent into halted sessions.

How much capital and risk discipline make sense

A common beginner mistake is thinking algo trading becomes sensible only with huge capital. That is not true. What matters first is that your strategy has stable rules, your risk per trade is defined, and your automation cannot spiral because of a repeated alert or execution mismatch.

The capital question is really a risk-control question. Can you survive a bad streak? Can you keep sizing constant while you validate the system? Can you tell whether underperformance came from the strategy, the slippage, or your execution chain? If the answer is no, adding more capital only hides the problem temporarily.

I usually suggest a staged rollout: paper logic first, then tiny live size, then gradual scaling only after the logging and post-trade review prove the workflow is behaving the way you expect.

• Do not scale a strategy you cannot explain trade by trade.
• Validate entry timing, exit timing, and broker response behavior separately.
• Use smaller size to test the system, not to chase excitement.
• Judge the stack on repeatability, not on one unusually good day.

What the retail algo framework changes for Indian traders

The reason older beginner advice is weak in 2026 is that it often ignores the current Indian environment. SEBI’s February 4, 2025 circular created the safer participation framework, and the later September 30, 2025 circular gave a glide path before making the framework applicable to all stock brokers from April 1, 2026.

You do not need to become a lawyer to act sensibly, but you do need to stop treating automation like a loose collection of Telegram hacks. A clean retail workflow now means being able to identify the strategy, control how it reaches the broker, and keep enough records to understand what happened later.

This is also why broker-specific behavior matters. The same TradingView alert can sit inside very different operating models depending on which bridge, vendor, or in-house setup you use. Production quality now means broker-aware design, not just clever chart logic.

• Know which part of your stack generates the signal and which part actually executes it.
• Avoid black-box vendor promises you cannot inspect or log.
• Keep strategy names, versions, and parameters explicit.
• Choose a workflow that can be monitored in real time and audited later.

The best route from beginner to serious operator

The beginner-to-pro path is not linear, but it is predictable. Traders who succeed usually follow this order: first define the setup, then test the chart logic, then clean the alerts, then add execution controls, and only then trust full automation with meaningful size.

Traders who fail usually reverse that order. They buy a bridge first, copy a strategy second, and only ask what the rules are after the first bad fill or duplicate trade. That sequence is emotionally exciting, but it is operationally backwards.

If you want a sustainable edge in India in 2026, think like an operator. Your broker, your logs, your alerts, and your risk rules are part of the strategy. Not separate from it. That mindset shift saves a huge amount of pain.

• Start with one market and one playbook before you add complexity.
• Use alerts to create discipline before you use them to trigger execution.
• Review every rejected order and every false trigger.
• Scale only when the boring operational parts are stable.