Features
Everything the engine does, running on an instance that is yours
This is the inventory: how a strategy gets written, what it connects to, what you can look at while it runs, how you test it before it is live, and what you can reach for mid-session. There is no tiering. An instance runs the whole platform, because there is only one customer on it to hold anything back from.
At a glance
Eight surfaces, one engine, one tenant
Every one of these ships on every instance. The sections below take each of them apart.
Unified broker API
One HTTP API for orders, positions, holdings, funds and market data, the same shape whichever broker sits behind it. Point TradingView, Amibroker, ChartInk, Excel or your own Python at it and change brokers without rewriting the caller.
Python strategy host
Write strategies in an in-browser editor, schedule them on IST times, and run several at once with process isolation and live logs. Each strategy runs in its own subprocess, so one failing does not take the others down.
No-code strategy builder
Build a strategy as a node graph: market data into indicators, indicators into conditions, conditions into orders. Export it as JSON, keep it in version control, import it into another instance.
Options analytics
A suite of options tools on the same live feed the strategies use: option chain, strategy builder, implied volatility smile, volatility surface, max pain, gamma exposure and open-interest tracking.
Paper-trading sandbox
A fully isolated sandbox with its own database and its own capital, with a realistic margin model and exchange-aligned auto square-off, so a strategy can be exercised end to end before it touches a live account.
Live market data feed
A single normalised WebSocket feed shared by every surface on your instance, so the chart, the strategy and the analytics tools are all reading the same tick.
Order approval mode
Run fully automatic, or require every order to be approved by hand before it is sent. The choice is per instance and can be changed at any time.
Alerts
Telegram notifications for fills, rejections, strategy errors and session events, so you learn about a problem from your phone rather than from your order book the next morning.
Write
Two ways to build a strategy, and you own both of them
Code if you write code, nodes if you would rather not, and nothing stops you running one of each on the same instance. Either way the logic is yours: we do not supply strategies and there is no library of ours to subscribe to.
Python strategy host
An editor in the browser, on your instance. Paste or write a strategy, save it, schedule it on IST times, and watch its logs stream while it runs.
- Each strategy runs in its own subprocess, so one of them failing does not take the others down with it.
- Several strategies run in parallel on the same instance, each on its own schedule.
- Logs stream live to the browser, and the whole log is on your instance to read or export afterwards.
- Strategy files are yours: version them, export them, delete them.
No-code flow builder
The same engine, driven by a node graph instead of a file. Market data feeds indicators, indicators feed conditions, conditions feed order execution.
- Drag nodes onto a canvas and wire them together; the graph is the strategy.
- Export a flow as JSON, keep it in version control, import it into another instance.
- Scheduled triggers and live price monitors run the same way a Python strategy does.
- A flow and a Python strategy can run side by side on one instance.
A third option is to write nothing on the instance at all and treat it as an execution endpoint, driven over its HTTP API from wherever your signal already lives. That is the next section.
Connect
One API in front, your own broker behind
Adapters for 31 Indian brokers ship with the engine, and they all present the same interface upward. The relationship with the broker stays yours: your account, your developer app, your key, your whitelisted address.
- One HTTP API, whichever broker is behind it
- Orders, positions, holdings, funds and market data in one shape. Swap the broker underneath and the caller does not change, because the mapping to each broker's own vocabulary happens inside the engine.
- The callers you already use
- TradingView alerts, Amibroker, ChartInk scans, an Excel sheet, a Python script on your laptop, or an MCP client. Anything that can make an HTTP request can drive the engine.
- Your own key, your own app
- You register the developer app at your broker and hold the credentials. They live encrypted on your instance and are never written to application logs, and revoking them at the broker stops everything at once.
- Interactive API documentation
- Your instance publishes its own API documentation, so the reference you are reading is the version of the engine actually running for you rather than a page about some other release.
your strategy -> your engine -> your egress IP -> your broker
(python, flow, or an HTTP call from anywhere)The engine addresses NSE, BSE, NFO, BFO, CDS, BCD, MCX and NCDEX, covering equity, futures and options, currency and commodities. What you can actually trade is set by your own broker's API and your own entitlements with them, not by us. Which brokers ship as adapters, and what connecting one involves, is on the brokers page.
Analyse
Options analytics on the same tick your strategy sees
A suite of analysis tools reading the instance's own market-data feed, so the chart in front of you and the strategy making decisions are not looking at two different prices.
One normalised WebSocket feed is shared by every surface on the instance. That is an architecture decision rather than a feature bullet: it is what stops the analytics and the execution disagreeing about what the market just did.
- Option chain, live on the same feed the strategies read
- Options strategy builder with payoff at expiry
- Implied volatility smile
- Volatility surface
- Max pain
- Gamma exposure
- Open-interest tracker
- Straddle chart
Test
A sandbox that cannot reach your broker
Every instance ships with a paper-trading sandbox: its own database, its own capital, a realistic margin model and exchange-aligned auto square-off. It is isolated from the live side the same way your instance is isolated from everyone else.
Separate store
Sandbox orders and positions are written to their own database, not to a flagged column in the live one. A sandbox run cannot appear in your live order book by accident.
Realistic enough to be useful
Margin and leverage are modelled, and positions square off on the exchange schedule rather than sitting open forever. A strategy that survives the sandbox has at least met the shape of the real constraints.
An inspector for every request
Requests and responses can be inspected as they happen, which is how you find out that the payload your strategy builds is not quite the payload you thought it was.
Paper trading is a rehearsal, not a forecast. It cannot reproduce slippage, queue position, partial fills in a thin book or your broker rejecting an order at 09:15, and a strategy that looks profitable in it can still lose money live. The risk disclosure puts that plainly.
Control
What you can reach for while the market is open
Automation is only comfortable when stopping it is easy. These are the controls that exist for the day something is not behaving.
Order approval mode
Run fully automatic, or require every order to be approved by hand before it leaves the instance. It is a switch you control, per instance, changeable at any time, and it is the sensible setting while a new strategy is earning trust.
Telegram alerts
Fills, rejections, strategy errors and session events pushed to your phone, so you find out about a problem from a notification rather than from your order book the next morning.
An order trail you can audit
Every request the engine made, every broker response and every decision in between, timestamped and stored on your instance. It is a record you read yourself rather than one you ask us to look up.
Your data, exportable
Order records, logs, strategy files and flow definitions all leave with you. There is no export you have to request and no format we hold hostage.
Underneath all of them is the plainest control of all: the broker account is yours, so revoking the API key in your broker’s own console stops every order your instance could place, immediately, without going through us.
Isolation
The feature underneath the feature list
Everything above runs on infrastructure with one occupant. That is not a bullet point at the end; it is the reason the rest of the page is worth anything.
Your own database
Your instance writes to its own database files on its own volume. There is no shared tenant table and no customer identifier threaded through a common schema, because there is no common schema: another customer's instance has no route to your data, and neither does a query that gets its WHERE clause wrong.
Your own dedicated egress IP
Your instance's outbound broker traffic leaves from a static IP address reserved to you and shared with nobody. That is the address you whitelist in your own broker's developer console, so your broker sees one stable source for your API activity and it is never mixed with anyone else's.
Your own engine instance
Your strategies run in processes belonging to your instance alone. A strategy that loops, leaks or crashes affects your instance and no other, and a restart is yours to ask for rather than an event that touches other customers.
Your broker credentials stay yours
You register your own developer app with your own broker and hold your own API key. The tokens live in your instance, and you can revoke them from your broker's console at any moment, at which point your instance stops trading and we cannot restore access without you.
Your code, your account
The strategies are yours: you write them, you schedule them, you start and stop them. We do not read them to trade alongside you, do not run them on anyone else's account, and do not have a discretionary switch that places an order in your account.
Your data, exportable
Order records, logs and strategy files are yours, and you can export them. If you stop using the service you leave with your data, and the instance and its dedicated address are decommissioned.
Included
There is no higher tier
Every surface on this page is on every instance. We do not hold features back for a premium edition, because a premium edition would mean running two versions of the engine to serve one customer each.
Pricing depends on the size of your instance, how many broker accounts you connect and the support you need, so it is quoted rather than listed. Tell us what you run and you will get a written quote with GST shown separately. The pricing page sets out what is charged for and what is not.
Not on the list
Four things the engine will never ship
triStack AlgoTrader is hosting infrastructure, not an investment adviser and not a signal provider.
A strategy marketplace, a signal feed, or any list of trades to copy. You write the algorithms.
A discretionary control on our side that can place, modify or cancel an order in your account.
Any backtest, projection or historical figure presented as an indication of what you will make.
A profit-share, a performance fee or any charge that moves with what your account does.
Get started
Run all of it, on one instance, for one customer
Tell us which broker you are with and what you want to run, and we will provision an instance with every surface on this page switched on. triStack AlgoTrader operates the infrastructure; the trading stays yours.
Your infrastructure, your code, your broker account. · [email protected]