FNOTrader FNOTrader Algo

Strategy Builder

Configure a new strategy top-to-bottom · save it or fire it straight to the broker.

New Strategy

1 Strategy2 Instruments3A Entry3B Exit3C BTST/STBT3D Overnight Protect4 Legs4B Adjust5 Risk & Cascading6 ExecutionSave
1 Strategy name your strategy and (optionally) start from a template
Name your strategy descriptively (shown in the Strategies page). Symbol is the underlying — every Step-2 instrument inherits it; override per-row if you need to mix. Template seeds Steps 2-6 with a recipe; tweak any field afterwards.
7 Strategy Summary consolidated view of every variable you've set — open to verify before saving
Show summary

Strategy View

Two views of the same data — by strategy, or grouped by broker account. 🔗 Broker deploys to an account; 📦 Portfolio optionally groups. Expand any row for its positions, orders, trades & logs.
no saved strategies — open Builder and click 💾 Save Strategy

Broker Accounts

Connect once, trade everywhere — accounts are shared across Options, Trade & Algo. Enable an account to let live strategies place orders through it; copy-trading mirrors them to your other accounts.

Copy Trading

Place once on the leader; the engine mirrors to followers with a size multiplier. Accounts are managed on the Broker Accounts page.
loading…

⇄ Copy Trading settings

Followers & multipliers — when you trade on the leader, each enabled follower gets leader lots × multiplier. (The leader can't follow itself.)

Portfolios

Deploy saved Strategies on a Broker with a Multiplier. Portfolio-level risk caps stop the whole container when the daily loss cap is hit.
no portfolios yet — click + New Portfolio to create one

Signals

Create a signal → it gets its own webhook URL. Send it from TradingView, Python, Amibroker, NinjaTrader or any program (or fire it manually). On hit, the linked strategies run / square-off on their broker accounts. We only receive signals — we don't generate them.

Signal Configuration

Strategy Selection

StrategySignal TypesRemove
add a strategy to configure its signal types
Click signal types in the order you want them to fire — the number shows the sequence. Click again to remove. Strategies fire top-to-bottom — reorder rows with ▲▼ to e.g. exit one strategy before entering another. Each strategy's line explains what its signal will do.

Link Brokers

StrategyBroker Accounts (× multiplier)
add a strategy first
Brokers are inherited from each strategy's own assignment — not editable here. To run a strategy on more brokers, assign it to more broker accounts (Portfolios / Builder) or set up Copy Trading.

Signal Dashboard

no signals yet — name one above and Save Signal Config

Cumulative Signal Logs

no logs available

Webhook

Fire your strategies from TradingView, Chartink, Python or any HTTP source. We only receive alerts — we never generate them.

Build your trigger

Pick the Signal that should receive the alert, say what the alert carries, and copy the generated URL + body straight into TradingView / Chartink / your script. Fields you leave blank keep their saved value.
1 · Webhook URL (TradingView "Webhook URL" field)

        
2 · JSON body (TradingView alert "Message" box)

        
3 · curl (test from any terminal — fires the strategy for real)

        

Sample bodies — copy & fill

Single leg — entry
{
  "signal": {
    "signal_type": "LONG ENTRY",   // the one field to always send
    "symbol": "TCS",                 // tradable root
    "fut_opt": "FUT",                // FUT (front month, auto-rolls) | CASH
    "qty": 2,                        // LOTS — the engine converts
    "sl": 30, "tgt": 50              // in the unit your strategy uses
  }
}
Multi leg — entry
{
  "signal": {
    "signal_type": "ENTRY",
    "legs": [
      { "underlying":"NIFTY", "expiry":"current",
        "option_type":"PE", "strike_offset":0,
        "side":"SELL", "qty":1 },
      { "underlying":"NIFTY", "expiry":"current",
        "option_type":"CE", "strike_offset":0,
        "side":"SELL", "qty":1 }
    ]
  }
}
// strike_offset = ATM ± N strikes (needs strike_selection "relative"
// on the saved strategy). Replaces the saved legs — and their SL/TGT.
Exit — whole or part
{ "signal": { "signal_type": "LONG EXIT" } }

// Closes the whole position. Add a qty to book only part
// of it and leave the rest running:
{ "signal": { "signal_type": "LONG EXIT", "qty": 1 } }

Every parameter you can send

Everything goes inside "signal". Only signal_type matters — every other field is optional, and anything you omit keeps the strategy's saved value.
ParameterSent onValuesWhat it does
The type — the one field to always send
signal_type
alias action
alwaysLONG ENTRY · SHORT ENTRY
LONG EXIT · SHORT EXIT
ENTRY · EXIT
short codes LE/SE/LX/SX/E/X also work, as do buy, stoploss, tp, square_off
What this alert is. Single-leg strategies use the LONG / SHORT forms; multi-leg use plain ENTRY / EXIT. The Signal must have a row wired for it — if it does not, the alert is refused and logged rather than doing something else. Omit it and every wired row fires, which is how existing integrations keep working.
Entry — what to trade, and its risk
symbolentryNIFTY · TCSUnderlying / tradable root on every leg.
fut_opt
alias instrument
entryFUT · CASH · OPTFUT resolves the front-month contract and auto-rolls; CASH is equity/spot.
expiryentrycurrent · next · monthly · YYYY-MM-DDContract expiry.
option_typeentryCE · PEOption type on every leg.
strike_offsetentryintegerATM ± N strikes. Needs relative strike selection on the strategy.
sideentryBUY · SELLDirection. Usually unnecessary — LONG ENTRY / SHORT ENTRY already say it.
qtyentryintegerIn lots — the same unit the strategy is configured in. The engine multiplies by the contract size before the order reaches the broker; the route's multiplier scales it after. Use qty_units to send raw contract units instead.
qty_unitsentryintegerRaw contract units, skipping the lot conversion — for senders that would rather compute the size themselves.
slentrynumberStop for this entry, in whatever unit the strategy already uses — percent of entry premium by default, points if the strategy is set that way. Use sl_pct or sl_points to state the unit explicitly.
tgt
alias target
entrynumberTarget for this entry, same unit rule as sl. Explicit forms: tgt_pct, tgt_points.
trailing
alias trail
entry{enabled, trigger_pct,
step_pct, lock_pct}
Trailing stop for this entry, as % of entry premium ("unit":"pts" for points).
legsentryarray of leg objectsMulti-leg only. Replaces the saved legs wholesale, their risk settings included. Leg fields: underlying, expiry, option_type, strike_offset, side, qty.
Exit — how much to close
qtyexitintegerOmit to close the whole position. Send a quantity in lots to release just that much of every open leg and leave the rest running — a 4-lot straddle sent 2 comes back as 2 lots CE + 2 lots PE, still a straddle. A quantity at or above what is open closes it anyway.
qty_pctexit1–100The same partial exit, as a percentage of what is still open, instead of an absolute quantity. qty wins if you send both.
Update risk — change a position already open (advanced)
sl_inr · target_inrupdatenumber, rupeesBasket stop / target. 0 removes the limit — and {"sl_inr": 0} is how you move to breakeven.
trailingupdate{enabled, trigger_inr,
step_inr, lock_inr}
Basket give-back trail: arm at trigger, floor at peak − lock, ratcheting every step.
profit_lockupdate{profit_lock_reach_inr,
profit_lock_min_inr,
profit_trail_step_inr,
profit_trail_lift_inr}
Basket absolute-floor lock. Can close the position — see the note below.
forceupdatetrueApply a profit lock whose floor is already breached. Default refuses and logs floor / peak / MTM.
legupdateinteger, first leg = 0Required with any of the three per-leg fields below.
sl_price · target_priceupdatenumber, premiumThat leg's stop / target as a premium price.
trailupdate{enabled, trigger_pct,
step_pct, lock_pct}
That leg's own trailing stop.
Omitted is not zero. Leaving a field out means “don't touch it”; sending 0 is a real value that removes a limit. An empty object ("trailing": {}) reads as omitted, so it cannot wipe a live trail.
Numbers may arrive as strings — TradingView substitutes its {{…}} placeholders as text, and that is accepted.
Anything not listed here can still be driven through {{signal.*}} placeholders in the saved params.

One URL — the alert names its type

Paste the same webhook URL into every TradingView alert for that strategy. Each alert says what it is in signal_type, and the Signal's strategy rows decide what it is allowed to be — so a type you never wired is refused and logged, not quietly turned into something else. An alert with no signal_type fires every wired row, exactly as before.
signal_typeRow to wireWhat happens
LONG ENTRYLong Entry (or Entry)Open a long. A repeat while one is already open is a pyramid add if the Signal allows it — see below.
SHORT ENTRYShort Entry (or Entry)Open a short.
LONG EXITLong Exit (or Exit)Close the long — fully, or partly if the alert carries qty.
SHORT EXITShort Exit (or Exit)Close the short, same rule.
ENTRY / EXITEntry / ExitMulti-leg strategies, which have no single side.
Update riskUpdate riskAdvanced — change the stop, target, trailing or profit lock of a position that is already open, without opening or closing anything.
Rows fire in the order shown on the Signals page, and the type chips within a row fire left-to-right — so a reversal is one row typed LX, SE: close the long, then open the short.

Quantity

  • Send lots — the same unit you configured the strategy in. "qty": 2 means two lots; the engine multiplies by that contract's size before the order goes to the broker, so you never have to know it.
  • On an entry, qty sets the size of every leg. On an exit it is optional: omit it to close the position, or send lots to release just that much and leave the rest running.
  • Raw contract unitsqty_units — for senders that would rather compute the size themselves. It skips the lot conversion entirely.
  • Per-route multiplier. Each strategy row on the Signals page has a multiplier that scales the final quantity — the way to run one alert at 1× on one broker and 3× on another.

Repeat alerts

On the Signals URL, a repeat same-side entry while that strategy is already live on that broker is ignored and logged by default — a retried or duplicated alert cannot multiply your position. Tick Pyramid on repeat signals to make each repeat add another position instead, up to Max positions. A Short Entry while a long is open is a reversal, not a repeat, and always fires.

Placeholders — {{signal.*}}

For anything the override table doesn't cover, put a placeholder in the saved params and let the alert fill it. Placeholders can target any parameter, including ones with no override — e.g. "sl_pct":"{{signal.sl}}", "target_pct":"{{signal.tgt}}", "strike_offset":"{{signal.offset}}", or the whole "legs":"{{signal.legs}}". Dotted and indexed paths resolve: {{signal.legs[0].strike_offset}}. A value that is exactly one token keeps its JSON type (numbers stay numbers); a token inside a longer string is substituted as text. An unresolved token is left in place so the misconfiguration is visible rather than silent.
Order of application: placeholders are filled first, then the LE/SE single-leg side, then the explicit override fields (so an override always wins over a placeholder), and finally the route's quantity multiplier.

What a webhook can and cannot change mid-trade

An Update risk Signal can move the stop, the target, the trailing config and the profit lock on a position that is already open — scenarios 12–15. What it cannot do is book part of one: an exit alert always flattens the whole position, and there is no quantity on an exit. Staged booking comes from the engine's own SL/TGT ladders (a % of remaining quantity per level), or from splitting the position into tranche strategies with an exit Signal each (scenario 11).

Scenarios — exactly what to pass

Single-leg strategies first, then multi-leg. Every body goes to the same URL; signal_type is what separates them.

1 · Go long

Needs a Long Entry row. Everything except the type is optional — leave a field out and the strategy's saved value is used.
{ "signal": { "signal_type": "LONG ENTRY" } }

// …or let the alert decide the instrument, size and risk:
{ "signal": { "signal_type": "LONG ENTRY",
              "symbol": "NIFTY", "fut_opt": "FUT",
              "qty": 1, "sl": 30, "tgt": 50 } }

2 · Go short

Needs a Short Entry row. Identical shape.
{ "signal": { "signal_type": "SHORT ENTRY", "symbol": "NIFTY",
              "fut_opt": "FUT", "qty": 1 } }

3 · Close the position

Needs a Long Exit or Short Exit row. No other field is needed — an exit with no quantity closes everything.
{ "signal": { "signal_type": "LONG EXIT" } }

4 · Book part of the position

Same Exit row, with a quantity. It releases that much of every open leg and leaves the rest running. Send it again at your next level, and again at the one after that — that is TP1 / TP2 / TP3 from TradingView.
{ "signal": { "signal_type": "LONG EXIT", "qty": 1 } }

// …or as a share of what is still open
{ "signal": { "signal_type": "LONG EXIT", "qty_pct": 50 } }
A quantity at or above what is still open simply closes the position, so an over-sized alert can never leave a fragment behind.

5 · Add to a winner (pyramid)

Just send the entry again. A repeat while the position is already open is an add — provided the Signal has Pyramid on repeat signals ticked, with Max positions set to how many adds you will accept. Left unticked (the default), a repeat is ignored and logged, so a retried alert cannot double your position by accident.
{ "signal": { "signal_type": "LONG ENTRY", "qty": 1 } }   // first add
{ "signal": { "signal_type": "LONG ENTRY", "qty": 1 } }   // second add

6 · Reverse

One strategy row typed Long Exit then Short Entry — the numbered chips show the order, and they fire left-to-right, so the flat happens before the new position.
{ "signal": { "signal_type": "SHORT ENTRY", "qty": 1 } }
Reversing between two different strategies instead: two rows on one Signal, row 1 typed Exit on strategy A, row 2 typed Entry on strategy B. Rows fire top-down and reorder with ↑ / ↓.

7 · Multi-leg — enter

Needs an Entry row. Send nothing and the saved basket is used as-is; send legs only when the alert genuinely decides the structure, because it replaces the saved legs and their risk settings.
{ "signal": { "signal_type": "ENTRY" } }

{ "signal": { "signal_type": "ENTRY", "legs": [
    { "underlying":"NIFTY", "expiry":"current", "option_type":"PE",
      "strike_offset":0, "side":"SELL", "qty":1 },
    { "underlying":"NIFTY", "expiry":"current", "option_type":"CE",
      "strike_offset":0, "side":"SELL", "qty":1 } ] } }

8 · Multi-leg — exit, whole or part

Needs an Exit row. A quantity reduces every leg equally, so a straddle stays a straddle.
{ "signal": { "signal_type": "EXIT" } }             // close it
{ "signal": { "signal_type": "EXIT", "qty": 1 } }   // halve a 150-lot basket

9 · One alert, several brokers at different sizes

Add a row per broker on the same Signal and set each row's multiplier. The alert never changes; the multiplier scales the size per account. A broker that is logged out is skipped with the reason in the log, not failed silently.
{ "signal": { "signal_type": "LONG ENTRY", "qty": 1 } }

// row 1 · Broker A ×1  →  1 lot
// row 2 · Broker B ×3  →  3 lots

10 · Change the stop or target on an open position

Advanced, and only if you want it — most strategies let the engine manage the trade after entry. Needs an Update risk row, which can change risk settings but can never open or close a position.
{ "signal": { "signal_type": "UPDATE", "sl_inr": 8000 } }        // basket ₹
{ "signal": { "signal_type": "UPDATE", "sl_inr": 0 } }           // breakeven
{ "signal": { "signal_type": "UPDATE", "leg": 0, "sl_price": 142.5 } }
{ "signal": { "signal_type": "UPDATE", "trailing": {
    "enabled": true, "trigger_inr": 25000,
    "step_inr": 5000, "lock_inr": 5000 } } }
A profit lock can close the position. Its floor comes from the peak profit the run has seen, not from where P&L is now, so one sent after a pullback may already be breached and would book the basket on the next tick. The engine refuses it and logs the floor, peak and current MTM — add "force": true only if immediate booking is what you want.

11 · Wiring it in TradingView

The Signal's URL goes in the Webhook URL field, the JSON in the Message box — the same URL in every alert for that strategy.
// TradingView substitutes its own {{…}} placeholders before sending,
// so they can fill our fields. Numbers may arrive as strings; fine.
{ "signal": { "signal_type": "LONG ENTRY",
              "qty": "{{strategy.order.contracts}}" } }
Don't pipe {{ticker}} into symbol for derivatives — a charting ticker like NIFTY1! is not the tradable root. Send the root, or leave symbol out and let the strategy hold it.

Test it from a terminal

curl -X POST 'https://algo.fnotrader.com/api/webhook/sig/<signal-token>' \
  -H 'Content-Type: application/json' \
  -d '{"signal":{"signal_type":"LONG ENTRY","symbol":"NIFTY","fut_opt":"FUT","qty":1}}'

# → {"signal":"NIFTY breakout","started":1,"squared_off":0,"updated":0}
# The counts tell you what the alert actually did.
# Point it at a paper broker account first.

Backtest

Entry signals (optional) TV strategy as signal: upload the TradingView Strategy Tester → List of Trades export as-is. Writing your own? Download the template

Backtest Report

Full replay result — equity curve, drawdown, Monte Carlo, monthly calendar and every trade.

Backtest History

Every backtest you run is saved here. Click any row to reload the full report — no need to re-replay the bars.
Run (IST) Strategy Symbol Period Cost / Slip Net PnL Trades Win % Max DD Status Actions
No backtests yet — run one from the Backtest tab.

🗑 Trash

Strategies and backtests you deleted. Restore puts an item back where it came from; Delete permanently removes it from this list. Nothing is lost from your account's records either way.

Deleted strategies

Strategy Type Deleted (IST) Actions
Loading…

Deleted backtests

Strategy Symbol Period Net PnL Deleted (IST) Actions
Loading…

✨ AI Access

Connect your AI assistant to FNOTrader MCP — build and backtest strategies by describing them in plain English.

Build & backtest by asking your AI

Connect Claude, ChatGPT or any AI assistant to FNOTrader MCP and describe strategies in plain English — the AI creates them and runs backtests on the same engine, data and credits as this app.

Two ways to connect. Apps with a sign-in button (Claude web & Desktop, ChatGPT) use Sign in with FNOTrader — nothing to copy. Command-line clients (Claude Code, Gemini CLI) use a personal token you generate at mcp.fnotrader.com/connect. Either way the server URL is the same: https://mcp.fnotrader.com/mcp
Setup

Connect in three steps.

Connectors⌕ +
+ Add custom connector
CONNECTED
NOT CONNECTED
01

Open Claude.

Go to Settings → Connectors and choose Add custom connector. Added once on the web, it works in the desktop and mobile apps too.

https://mcp.fnotrader.com/mcp
02

Add the FNOTrader URL.

Name it FNOTrader and paste the connector URL. No token to copy.

F
Connect FNOTrader to Claude
Approve & connect
03

Sign in with FNOTrader.

Authorize once in your browser with your regular fnotrader.com login. Enable FNOTrader in any chat and just ask.

terminal
$ claude --version Claude Code, ready.
01

Open your terminal.

Anywhere a claude session runs — no settings screen needed.

terminal
$ claude mcp add \ --transport http fnotrader \ https://mcp.fnotrader.com/mcp
02

Add the FNOTrader server.

One command. Leave the token out — Claude Code signs you in.

terminal
/mcp fnotrader ✓ connected 37 tools available
03

Authenticate.

Run /mcp, pick fnotraderAuthenticate. Your browser opens the FNOTrader sign-in; approve it and you're connected.

Connectors⌕ +
+ Create
CONNECTED
NOT CONNECTED
01

Turn on Developer mode.

Settings → Connectors → Advanced → enable Developer mode. Plus, Pro and Business plans.

https://mcp.fnotrader.com/mcp
02

Create the connector.

Name FNOTrader, Authentication OAuth, and this MCP server URL.

F
Connect FNOTrader to ChatGPT
Approve & connect
03

Sign in with FNOTrader.

Approve once, then in a chat use + → Developer mode and tick FNOTrader. The “unverified connector” notice is expected for every custom connector.

Tools & MCP⌕ +
+ Add Custom MCP
CONNECTED
NOT CONNECTED
01

Open Cursor Settings.

Settings ⚙ → Cursor Settings → Tools & MCP → Add Custom MCP, or edit ~/.cursor/mcp.json directly.

terminal
{ "mcpServers": { "fnotrader": { "url": "https://mcp.fnotrader.com/mcp" } } }
02

Add the FNOTrader server.

Paste this into mcp.json — no key, Cursor detects OAuth.

F
Connect FNOTrader to Cursor
Approve & connect
03

Sign in with FNOTrader.

Cursor opens your browser to authorize. The tools then appear under MCP — use them from Agent chat.

Connected apps⌕ +
+ Add custom app
CONNECTED
NOT CONNECTED
01

Pick your Gemini.

Web app: Settings → Connected apps → Add custom app (rolling out). CLI: edit ~/.gemini/settings.json. Enterprise: your admin adds it as a custom MCP server.

terminal
{ "mcpServers": { "fnotrader": { "httpUrl": "https://mcp.fnotrader.com/mcp", "headers": { "Authorization": "Bearer fntmcp_…" } } } }
02

Add the FNOTrader server.

The web app takes the URL and signs you in. The CLI takes a token from the token page:

F
Connect FNOTrader to Gemini
Approve & connect
03

Verify with /mcp.

Run /mcp in the CLI (or open a chat on the web) — FNOTrader should list its tools. Then just ask.

MCP servers⌕ +
+ Add server
CONNECTED
NOT CONNECTED
01

Open your MCP client.

VS Code Copilot, Windsurf, Grok, LangChain / agno pipelines, your own agent — anything that speaks MCP over streamable HTTP.

https://mcp.fnotrader.com/mcp
02

Point it at the URL.

One endpoint, every client. Streamable HTTP — no SSE shim needed.

F
Connect FNOTrader to your AI
Approve & connect
03

Authenticate.

Use OAuth if the client offers a sign-in. Otherwise send a token from the token page as Authorization: Bearer fntmcp_…, or append ?key=fntmcp_… to the URL.

Other ways to connect — config files, headless & CI
Claude Desktop — config file
Add to claude_desktop_config.json (needs Node.js), then restart Claude.
{ "mcpServers": { "fnotrader": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.fnotrader.com/mcp", "--header", "Authorization: Bearer YOUR_TOKEN"] } } }
Claude Code — headless / CI
When no browser is available to sign in with, send the header instead.
claude mcp add --transport http fnotrader https://mcp.fnotrader.com/mcp --header "Authorization: Bearer YOUR_TOKEN"
Any client — every auth option
Sign-in: OAuth — pick "sign in" if the client offers it or Header: Authorization: Bearer YOUR_TOKEN or keyed URL: https://mcp.fnotrader.com/mcp?key=YOUR_TOKEN
Tokens come from mcp.fnotrader.com/connect — rotate or revoke anytime.
Then just ask — e.g. "Backtest a NIFTY 09:20 short straddle with 30% SL per leg for 2023–2025" or "Try the same on RELIANCE and sweep the SL at 20/30/40%".
📘 Full setup guide ✨ Everything you can ask 🔑 Your token & access

Your usage

loading…
Backtests run by your AI appear in Backtest History here, exactly like runs from this app.
Fair usage applies: 120 AI tool calls/min, 30 backtest submissions/hour, 4 concurrent backtests.

Journal

Performance from every executed run — overall, per portfolio, per strategy. Captured automatically when a run finishes; gate-blocked runs are excluded from the metrics.

Day Summary

Strategy-wise

StrategyModeAccounts RunsOrders PositionsPnL ₹

Account-wise

Account / StrategyMode RunsOrders PositionsPnL ₹

Equity curve

cumulative realized P&L by day, with the drawdown band — same read as the backtest report.
loading…

Portfolio level

loading…

Holding-time analysis

loading…

Strategy level

click a strategy for its run-by-run drill-down
loading…

Historical Charts

Replay any trading day's CE / PE option candles and combined premium straight from the bar archive, with backtest entry/exit markers. Cursor is synced across all three charts.
Pick a date and click Load charts, or click a backtest day row below.
DateATM Expiry DTE OpenCloseReason PnL ₹ Cum PnL ₹ DD ₹ Legs (entry → exit)
Select a backtest result above to see its per-day trades. Click any row to load that day's CE/PE + combined charts with entry/exit markers.

Marketplace

📘 How it works
Subscribe to a creator's strategy and deploy it on your own broker account — the creator's recipe stays protected; you see every order, position and P&L on your account. Performance shown is computed from the creator's own runs on this platform — never self-reported.

Risk Settings

Per-user daily loss kill-switch + trade count cap. Resets at IST midnight.

Limits

Your personal daily circuit-breaker. Set a rupee loss and/or a trade count that, once hit for the day, squares off all your running strategies and blocks new launches until IST midnight — a hard stop against a bad day running away. Leave a field at 0 to disable that check.
When realized P&L falls below −X, kill-switch trips: running strategies flatten, new ones refused.

Per-Broker Hard Limits

Caps applied to every strategy routed through a broker account — across all portfolios.
Daily Loss Cap — when today's combined P&L across the account drops below −X, every live run on it is squared off and no new runs launch until IST midnight. Max Concurrent — refuse to launch a new run once this many are already live on the account. Capital Cap — refuse an order whose margin would push exposure past this. 0 = no limit.
loading…

Today's State

A live tally of your real-money trading for the current IST day — this is exactly what the kill-switch above watches. Realized P&L is booked (closed-leg) profit/loss so far today; Trades today counts each executed leg; Kill switch shows OK, or TRIPPED once your Max Daily Loss / Max Daily Trades limit is hit (running strategies flatten and new ones are refused). It resets automatically at IST midnight, or use Reset today to clear it manually.
loading…