Yes, absolutely.

In fact, testing the syntax before going live is a good practice.

You can use the <b>Simulation</b> feature available inside the JSON Bridge.

Just follow these steps:
<h3><b>Step 1</b></h3>
Go to JSON Bridge → Generate Syntax

Generate and copy your strategy order JSON. 
<h3><b>Step 2</b></h3>
On the same page, you will find an option called:

Simulation -> Open it.
<h3><b>Step 3</b></h3>
In the Webhook URL field, paste the webhook URL of your JSON Bridge.
<h3><b>Step 4</b></h3>
In the JSON field, paste the syntax that you generated previously.
<h3><b>Step 5</b></h3>
Click: Simulate
<h3><b>Step 6</b></h3>
Now go back to your JSON Bridge dashboard.

If everything is configured correctly, you will be able to see the order execution inside the bridge itself.

=> After that you can use that strategy order syntax in the trading view alerts.

Yes, this is possible.

If the signal came before you connected the bridge, then the bridge will not know about that previous signal.

In that case:

<li style=”font-weight: 400;” aria-level=”1″>First configure your Upside and Downside Execution properly
<li style=”font-weight: 400;” aria-level=”1″>Then open the Custom Bridge

You will find a button called: “Place Manually” using that button, you can place the trade directly from AlgoDelta. 

After that: Your position gets opened ,the bridge remains active and future BUY/SELL signals from TradingView will be handled automatically.

Yes, this is completely possible with AlgoDelta.

You can do this using the Custom Bridge.

While setting up the bridge, configure the Call Option in the Upside Execution section and configure the Put Option in the Downside Execution section.

After that, when a BUY signal comes from your strategy or indicator, the upside execution runs and the selected Call Option is traded. When a SELL signal comes, the downside execution runs and the selected Put Option is traded.

This allows you to keep your TradingView strategy on the Nifty chart while AlgoDelta handles the option execution automatically.

If you want positions to reverse automatically, you can enable the “Exit on Opposite Signal” setting.

With this setting enabled, an existing Call position can be exited automatically when a SELL signal is generated, and a new Put position can be opened immediately. The same logic works in reverse when the signal changes from SELL to BUY.

So, you can efficiently automate option trading based on your TradingView signals without manually switching between Call and Put positions.

Yeah, indicator setup is slightly different from strategy setup.

In this you have to set the 2 alerts one for the Upside and the other for the DOWNSIDE execution.

Just follow these steps:

Step 1: Go to your Custom Bridge page and click the yellow copy icon and copy the webhook URL.

Step 2: Now open TradingView and apply your indicator on the chart.

Step 3: Click on Alerts (clock icon).

Step 4: In Condition dropdown, select your indicator.

Step 5: Now in the Crossing dropdown, select -> “Crossing Up” for the UP-alert setup.

And select “Crossing Down” for the DOWN alert setup

Step 6: In the Trigger option, you can select anything you want. But we suggest: Once Per Bar Close.

Step 7: In the Message box, enter -> “UP” (if we made an alert for UPSIDE Execution)

Enter “DOWN” (if we made an alert for DOWNSIDE Execution).

This is important because the UP signal triggers upside execution.

Step 8: Now go to the Notifications section -> Enable Webhook URL option -> Paste the copied webhook URL there -> Then save the alert.

=> Now whenever: indicator gives UP signal → upside execution runs

=> Note: To make the UP or DOWNSIDE alert just have to make a change in Step 7.

=> And if you still have some confusion you can refer to the video below: Connection with trading View

Yeah, this confuses many people in the beginning.

After creating the custom bridge, just follow these steps:

Step 1: In the Custom Bridge page, click the yellow copy icon on the custom bridge page and also you can find the inside bridge at the upper right corner.

You will get the webhook URL copied.

Step 2: Now go to TradingView and open your strategy chart.

Step 3: Click on the Alerts icon (clock icon).

Step 4: In the Condition dropdown, select your strategy.

Step 5: In the Message box, keep only this: {{strategy.position_size}}

Step 6: Now go to the Notifications section below.

Enable Webhook URL option

Paste the copied webhook URL there

Step 7: Save the alert.

=> Now whenever:

-> BUY signal comes → upside execution script runs

-> SELL signal comes → downside execution script runs

=> That’s it. Your TradingView strategy is now connected with the bridge

=> And if you have the still some confusion you can refer the below video:

Connection with trading view

Yeah I get your confusion.
You do not need to find the Bridge Key from anywhere.
You have to create your own key manually It can be any simple alphanumeric value
Example:
Test123
Algo001
MyBridge9

This warning appears because the account is using older Fyers broker credentials. You need to add the new Fyers credentials by following this blog:

Copy Trading with FYERS

You can place orders across any brokers, regardless of which broker is used as the master account or the child account.

If you have different brokers then you can use the same static IP for all of them.

However, if you have multiple accounts under the same broker, you will need separate static IPs for each account. For example, if you have 10 Kotak accounts, then you will need 10 static IPs

For detailed information about static IPs, you can read this blog.

What Is a Static IP? Complete Guide for Traders in India

When the order is completed/executed in the master account, then it will be placed in the child accounts.

List of brokers in which daily login is not required:

• Angel One
• IIFL New
• Jainam – Normal
• Kotak Securities
• Motilal – Normal
• Zerodha Without API
• DefineEdge
• Groww Auto
• Enrich
• R Money
• Trade Smart
• Nirmal Bang
• Rikhav
• Centrum
• JM Finance

You just need to assign a static IP on the Dhan broker’s end.

If you want to know in detail, you can follow this blog:

Copy Trading with Dhan

Yes sir, if you are using IIFL, Groww, Kotak, or JainamLite, then the PNL is not showing from the API side for these brokers. Therefore, you will not be able to see the PNL for those brokers.

Yes, this happens because of candle instability at market open.

At 9:15 the volatility is very high, candles move very fast, ATR is not stable initially that’s why this happens.

So, the main fix is using only closed candles, wait for enough candles like 20 candles minimum and use proper ATR smoothing/alignment.

After first few candles your super trend will be working great.

Can refer the below code:

def compute_supertrend(candles, period=10, multiplier=3):
    if len(candles) < period + 2:
        return []
    trs = []
    for i in range(1, len(candles)):
        h = candles[i]["high"]
        l = candles[i]["low"]
        pc = candles[i - 1]["close"]
        tr = max(
            h - l,
            abs(h - pc),
            abs(l - pc)
        )
        trs.append(tr)
    if len(trs) < period:
        return []
    atr_vals = [sum(trs[:period]) / period]

    for i in range(period, len(trs)):
        atr = (
            (atr_vals[-1] * (period - 1)) + trs[i]
        ) / period
        atr_vals.append(atr)
    atr = [None] * period + atr_vals

    final_upper = [None] * len(candles)
    final_lower = [None] * len(candles)
    supertrend = [None] * len(candles)
    direction = [None] * len(candles)

    result = []
    for i in range(len(candles)):
        if atr[i] is None:
            result.append(None)
            continue
        h = candles[i]["high"]
        l = candles[i]["low"]
        c = candles[i]["close"]
        hl2 = (h + l) / 2
        upper_band = hl2 + (multiplier * atr[i])
        lower_band = hl2 - (multiplier * atr[i])
        if final_upper[i - 1] is None:
            final_upper[i] = upper_band
            final_lower[i] = lower_band
        else:
            prev_upper = final_upper[i - 1]
            prev_lower = final_lower[i - 1]
            prev_close = candles[i - 1]["close"]
            final_upper[i] = (
                upper_band
                if upper_band < prev_upper or prev_close > prev_upper
                else prev_upper
            )
            final_lower[i] = (
                lower_band
                if lower_band > prev_lower or prev_close < prev_lower
                else prev_lower
            )

        if supertrend[i - 1] is None:
            if c <= final_upper[i]:
                supertrend[i] = final_upper[i]
                direction[i] = "SELL"
            else:
                supertrend[i] = final_lower[i]
                direction[i] = "BUY"
        elif supertrend[i - 1] == final_upper[i - 1]:

            if c <= final_upper[i]:
                supertrend[i] = final_upper[i]
                direction[i] = "SELL"
            else:
                supertrend[i] = final_lower[i]
                direction[i] = "BUY"
        else:

            if c >= final_lower[i]:
                supertrend[i] = final_lower[i]
                direction[i] = "BUY"
            else:
                supertrend[i] = final_upper[i]
                direction[i] = "SELL"

        result.append({
            "supertrend": round(supertrend[i], 2),
            "signal": direction[i]
        })

    return result

# Sample candles - reolace thsi with actual live candle data
candles = [
    {"high": 101, "low": 99, "close": 100},
    {"high": 102, "low": 100, "close": 101},
    {"high": 103, "low": 101, "close": 102},
    {"high": 104, "low": 102, "close": 103},
    {"high": 105, "low": 103, "close": 104},
    {"high": 106, "low": 104, "close": 105},
    {"high": 107, "low": 105, "close": 106},
    {"high": 108, "low": 106, "close": 107},
    {"high": 109, "low": 107, "close": 108},
    {"high": 110, "low": 108, "close": 109},
    {"high": 111, "low": 109, "close": 110},
    {"high": 112, "low": 110, "close": 111},
    {"high": 113, "low": 111, "close": 112},
]

result = compute_supertrend(candles)

for row in result:
    print(row)

Yes, Zerodha’s WebSocket provides the tick-tick data, we will have to aggregate the ticks and convert that into candle of different timeframes whatever you want.

To do that can refer below code:

from datetime import datetime

CANDLE_STATE = {}

def build_candle(symbol, tick, timeframe=1):
    ts = tick["timestamp"]
    price = tick["price"]

    # Adject timeframe
    minute = (ts.minute // timeframe) * timeframe
    bucket = ts.replace(minute=minute, second=0, microsecond=0)

    if symbol not in CANDLE_STATE:
        CANDLE_STATE[symbol] = {}

    candles = CANDLE_STATE[symbol]

    # Create new candle
    if bucket not in candles:
        candles[bucket] = {
            "open": price,
            "high": price,
            "low": price,
            "close": price
        }
    else:
        c = candles[bucket]
        c["high"] = max(c["high"], price)
        c["low"] = min(c["low"], price)
        c["close"] = price

    return candles
# Replace the tick's static data with the live feed
ticks = [
    {"timestamp": datetime(2026, 4, 24, 9, 15, 5), "price": 100},
    {"timestamp": datetime(2026, 4, 24, 9, 15, 20), "price": 102},
    {"timestamp": datetime(2026, 4, 24, 9, 15, 40), "price": 99},
    {"timestamp": datetime(2026, 4, 24, 9, 16, 10), "price": 105},
]

symbol = "TEST"

for t in ticks:
    candles = build_candle(symbol, t, timeframe=1)

# Print result
for time, candle in candles.items():
    print(time, candle)