Trade Node

The Trade node is one leg of a position: where an Entry's order lands and where its exits attach. How exits connect, how to read the live trade, and how trades split a position for partial exits.

NodeBy AlgoLiftUpdated 4 min read
On this page 8How it worksNo outputs, on purposeSplitting a position between legsExample: take half at the first target, let the rest runSettingsUse something else whenWhen it doesn't behaveGoing further

An Entry decides when to get in. The Trade node is what it gets into: one leg of the position, carrying the exits that will get it out again. Most strategies have one per Entry. Partial exits have two, and once a canvas holds more than one, the builder numbers them Trade 1, Trade 2 and so on, in the order you added them.

Takes
An Entry's order, plus an optional Qty Override
Gives
Nothing to wire. Exits attach to it and Trade Variables read from it
Reach for it
Every Entry needs at least one

How it works

Wire an Entry's output, or a Scale-In Entry's, into Order. That makes this node a leg of that trade.

A leg needs a way out, and there are two ways to give it one. The usual one is a Bracket Order: click Attach to a trade on the bracket, then click this node. The button then reads ✓ Exits Trade (or ✓ Exits Trade 1 when there are several), so you can see which trade each bracket closes. The other is the setter rail along the bottom, where you drag out Target Profit, Stop Loss or Exit Condition to make a Set Target Profit, Set Stop Loss or Set Exit Condition tied to this leg.

The builder accepts a leg with a bracket, a leg with both a target setter and a stop setter, or a leg with an exit condition. Under a bracket, Target Profit and Stop Loss are greyed out because the bracket owns them, but Exit Condition stays available. So "exit on a signal, with a hard stop behind it" is one bracket plus one exit condition. A leg can take several Exit Conditions: every one runs, and the first to fire closes the leg, the same as one Exit Condition fed by an OR. Going the other way, a leg that already has a hand-built target or stop can't take a bracket until you delete that setter.

No outputs, on purpose

Nothing wires out of a Trade node. To use a live value of the trade, drag it off the rail along the top: Entry Price, Entry ATR, Quantity, Current Target or Current Stop. Each drops a Trade Variable that reads this leg, and you wire that into the leg's exit logic like any other number. Time spent in the trade comes from a Time Since set to this trade's entry, or from the bracket's Time exit.

The color swatch tints everything tied to the leg (its bracket, setters and variables), which helps a lot once a canvas has several.

Splitting a position between legs

Wire one Entry into two Trade nodes and its position splits between them. With both Qty Override inputs empty, the legs share it evenly: an Entry trading 2 contracts puts one in each.

For an uneven split, wire a number into each leg's Qty Override. The easiest way to think of them is as shares: 50 and 50 is half each, 75 and 25 on a 4-contract position is three and one. Whenever the overrides add up to the whole position or more, the engine scales them down to fit, in proportion. Pick shares that divide your size into whole contracts, or you'll trade fractions.

Mixing sized and empty legs is where it gets subtle. A leg with an override gets that many contracts, and the empty ones split what's left. If the overrides already cover the whole position, an empty leg gets nothing and never opens. The builder warns about these combinations, but the simple rule is to give every leg an override, or none.

Example: take half at the first target, let the rest run

Say you trade NQ 5m with a Constant of 2 in the Entry's Quantity. Wire the Entry into two Trade nodes and leave both Qty Overrides empty, so each leg trades one contract. The builder names them Trade 1 and Trade 2.

Attach a Bracket Order to Trade 1 with a 20-point target and a 15-point stop. Attach a second bracket to Trade 2 with the same 15-point stop, a 60-point target, and Stop Mode set to Trailing, then set the trail on the Constant the mode adds (25 points, say). The first contract banks the quick move. The second stays with the trend, and its stop follows price up once the trade is working.

Settings

It has no settings of its own. Everything it does comes from what's wired into it and attached to it.

Use something else when

A target and a stop as distances
The usual way to give a leg its exits, measured from the fill, the signal bar or a level, and fixed when the trade fills.
Add to the position
A second leg off the same Entry splits one position. Adding size later takes a Scale-In Entry, with a Trade node of its own.
A live value of the trade
Drag it off the top rail. The node itself has no outputs.

When it doesn't behave

“Missing a valid exit strategy”

The trade has no way out the builder accepts. Attach a Bracket Order to it, or give it both a Target Profit and a Stop Loss, or an Exit Condition. A Stop Loss setter on its own isn't enough.

One of my legs never opens

The other legs' Qty Overrides already add up to the whole position, so the leg without one gets nothing. Give every leg an override (50 and 50, say), or clear them all.

My bracket won't attach to this trade

The leg already has a hand-built Target Profit or Stop Loss, and the builder says so when you click it. Delete the setter, then attach the bracket. If you want your own logic as well, wire it into the bracket's stop or target input instead.

Going further

Be as honest about the split as about any parameter. Half off at the first target versus all-in is a real design choice, but trying 50/50, 60/40 and 70/30 and keeping whichever looked best is a sweep over the past like any other. Decide the split from what you believe about the setup (does it usually run, or usually stall?), then test that.

Or ask the copilot