Shifu docs

Shifu sits between TradingView and the brokerage accounts you connect. Your chart fires an alert, Shifu reads it, and sends the matching order to whichever of your accounts you pointed that bot at. That is the entire job.

Two things drive every order: the alert your script sends, and the configuration on the bot and on each account you routed it to. Nothing else is added along the way.

• A bot is one TradingView alert wired to one or more of your accounts. It has its own private link.
• An account is a brokerage or prop-firm account you connect, or a paper account for rehearsal.
• Routing is the on/off switch plus the size rule that connects a bot to an account.

1. 1 · Connect an account

   Dashboard → Accounts → Connect account. Paper needs no broker login and no plan — every member gets a Practice account, free — and it is the right place to start — fake money. One honest limit: Shifu has no market data feed, so a resting take-profit or stop only resolves when your next alert on that symbol proves the level was reached. Practice fills a market order right away at your alert's price. A limit or stop order waits until a later alert's price reaches it. For a real account, pick Tradovate or Rithmic — the ProjectX card is there but disabled until that route is built. Trading on NinjaTrader? Pick NinjaTrader and Shifu asks the one question that resolves it: if you sign in with a Tradovate or NinjaTrader username and password, Shifu connects over Tradovate; if your firm gave you a system name like “Rithmic 01”, it connects over Rithmic.

2. 2 · Create a bot

   Dashboard → Bots → New bot. Set a name, a Default ticker (for example MES1!), a Default size, and How to size each trade. On save you get your private link and a key that is shown exactly once — copy it then. If you lose it, rotate the secret from the bot’s Setup tab and re-paste the new link in TradingView.

3. 3 · Point the bot at your accounts

   Open the bot → Account routing. Turn on each account this bot should trade. Per account you choose Contracts (this account always trades that many, whatever the alert says) or × alert (multiply whatever size the alert sends). If the bot sizes from the alert, only the multiplier applies.

4. 4 · Wire it into TradingView

   On the bot’s Setup tab, copy your link and copy a ready-made message. In TradingView press Alt+A, set the condition to your strategy or indicator with “Any alert() function call”, open the Notifications tab, tick Webhook URL and paste the link, then paste the message into the Message box. If your script builds its own alert text, leave the Message box empty. Click Create.

5. 5 · Fire a test, then go live

   Send a test signal from the bot’s Setup tab and watch it land under Alerts. When you are ready for real orders, turn on Live routing on the account — the next alert can place a real order at your broker.

You do this once per bot. The alert lives on your chart in TradingView; Shifu only ever sees the message that alert sends. Which message you paste comes down to one question — who writes it, your script or you? Pick your path first, then follow the dialog steps below.

1. Path A · Your script writes the message

   The least setup. You coded the script yourself, or the algo you bought has Shifu, PickMyTrade or TradersPost alerts built in. Follow the algo’s own guide for the alert. It will say one of two things. Most say to pick “alert() function calls only” (on an indicator it reads “Any alert() function call”) and leave the Message box alone. Some say to pick “Order fills only” and put {{strategy.order.alert_message}} in the Message box. Either way the message comes from the script, and Shifu reads it as it is (a PickMyTrade or TradersPost message within the limits named under Alert format).

2. Path B · A strategy that does not

   A paid or locked strategy with no webhook settings of its own. Pick “Order fills only” and paste the strategy message from the bot’s Setup tab. TradingView reports each fill, and the position lines in that message let Shifu tell entries, exits and reversals apart. No code needed.

3. Path C · It’s an indicator

   It draws buy and sell signals and places no orders. Make one alert per side you trade (long, short, exit), each set to “Once Per Bar Close”, and paste that side’s message from the Setup tab. TradingView does not fill in {{strategy.…}} words on an indicator alert, so these messages have none.

1. 1 · Open the alert dialog

   On your chart, press Alt+A (or click the clock icon at the top right). TradingView’s “Create Alert” panel opens.

2. 2 · Set the condition

   In the Condition area, pick your strategy or indicator, then the trigger for your path above : what your algo’s guide says for Path A (usually “alert() function calls only”), “Order fills only” for Path B, or your indicator’s own condition for Path C.

3. 3 · Paste the message

   Find the “Message” box. TradingView has already put its own text there. Delete all of it, then paste the message you copied in Step 2. On Path A leave this box alone, unless your algo’s guide says to put {{strategy.order.alert_message}} there.

4. 4 · Turn on the webhook

   Click the Notifications tab at the top of the panel and tick “Webhook URL”. Paste your link from the bot’s Setup tab into that field. Paste the whole link, including the key on the end — that key is what proves the alert came from you.

5. 5 · Create

   Click Create. From now on the alert fires whenever your condition is true, and each fire sends exactly one message to Shifu.

The simplest alert that does something is an action, a symbol, and a key that makes this alert unique. Everything below that is you asking for more precision.

{
  "action": "buy",
  "symbol": "MES1!",
  "quantity": 1,
  "time": "{{timenow}}"
}

actionrequiredbuy · sell · close · exit · reverse

What to do. buy and sell enter in that direction. On paper and Tradovate accounts a new entry first closes the position already open in that contract. The one exception is a strategy adding to a trade it already holds: when that alert carries the position and size lines of the ready-made strategy message, Shifu adds to what the account holds instead (see “A new entry replaces the old position on paper and Tradovate” under Brokers). On Rithmic accounts an entry is sent as it is, so it adds to, reduces or flips what is open. A partial exit (a strategy taking part of its position off) is not an entry when the alert carries the position lines of the ready-made strategy message: with its two size lines, paper and Tradovate accounts take the same share off where they can, and Rithmic accounts keep the full size until the strategy’s full exit; without the size lines, nothing is sent. Without the position lines, Shifu cannot tell a partial exit from an entry, so it is sent as an entry. close and exit both flatten your position in that symbol. reverse asks to flip an open position to the other side — see the broker notes below, because reverse is not accepted on every account type.

symbolrequireda futures contract, e.g. MES1!

Which contract to trade. Use the TradingView continuous form (MES1!, MNQ1!) and Shifu resolves it to the current front month for you, so you never have to edit an alert at rollover. A dated contract works too, but stops working once it expires.

timerequired{{timenow}}

When the alert fired. It is how Shifu tells a repeat of the same alert from a new one: an exact repeat is treated as one alert, so a retriggered or double-delivered alert cannot fill twice. Keep it on its own line, exactly as the ready-made message has it. TradingView’s message check cannot read a {{word}} that is glued to other text.

order_idoptional{{strategy.order.id}}

Strategy alerts only. TradingView’s own name for the order: it tells two different fills in the same bar apart. Leave it out on an indicator alert: the action (buy, sell, exit) does that job there.

idempotency_keyoptionalany text up to 512 characters

For your own scripts only: a unique id you build yourself. When it is present it is used instead of time and order_id. The ready-made messages do not use it.

quantityoptionalwhole number, 1 to 10,000

How many contracts the alert is asking for. Used when the bot is set to size from the alert. Left out, the bot’s Default size is used instead. Each account can still scale or override this on the Account routing tab.

order_typeoptionalmarket · limit · stop · stop_limit

How the entry goes to market. Defaults to market when you leave it out.

limit_priceoptionala price

The limit price for the entry. Required whenever order_type is limit or stop_limit — the alert is refused without it.

stop_priceoptionala price

The trigger price for the entry. Required whenever order_type is stop or stop_limit — the alert is refused without it.

priceoptionala price

Where your chart was when the alert fired. It is a reference, never a constraint: a market order still fills at market. Shifu uses it to price paper fills honestly and to place bracket levels exactly where your chart computed them, so include it whenever your script can.

take_profitoptionala price

An absolute price for a resting take-profit. When present, Shifu places it at the broker as a limit order the moment the entry fills. Leave the field out entirely if you do not want this leg.

stop_lossoptionala price

An absolute price for a resting stop. Placed at the broker alongside the take-profit; a fill on either one cancels the other. Leave the field out entirely if you do not want this leg.

trail_distanceoptionala distance in the symbol’s price units

How far behind the best price the stop should follow. Including this field turns the stop leg into a trailing stop at the broker instead of a fixed one. Your initial stop still sits exactly where stop_loss put it, so your opening risk always matches your plan.

trail_triggeroptionala distance in the symbol’s price units

How far price must move in your favour before the trail starts following. Leave it out to trail from entry. Honoured on Tradovate and Rithmic; simulated on paper.

market_positionoptionallong · flat · short

Where TradingView says the strategy stands after this order. This is what makes a strategy you cannot edit fully automatable: a bare buy or sell that leaves the strategy flat is read as a close.

prev_market_positionoptionallong · flat · short

Where the strategy stood before this order. Paired with market_position, a straight flip from long to short (or back) is read as a reverse rather than a plain entry.

metaoptionalany JSON object

Anything else you want kept with the alert — a setup name, a tag, a note. Shifu stores it with the record so you can see it later. It never changes routing.

{
  "action": "buy",
  "symbol": "MES1!",
  "quantity": 1,
  "price": 5000.25,
  "take_profit": 5010.25,
  "stop_loss": 4995.25,
  "time": "{{timenow}}"
}

{
  "action": "sell",
  "symbol": "MNQ1!",
  "quantity": 1,
  "price": 18250.00,
  "stop_loss": 18270.00,
  "trail_distance": 8,
  "trail_trigger": 12,
  "time": "{{timenow}}"
}

{
  "action": "buy",
  "symbol": "MES1!",
  "quantity": 1,
  "order_type": "limit",
  "limit_price": "{{close}}",
  "time": "{{timenow}}"
}

{
  "action": "buy",
  "symbol": "MES1!",
  "quantity": 1,
  "order_type": "stop",
  "stop_price": 5012.50,
  "time": "{{timenow}}"
}

{
  "action": "sell",
  "symbol": "MNQ1!",
  "quantity": 2,
  "price": 18250.00,
  "take_profit": 18230.00,
  "stop_loss": 18262.00,
  "time": "{{timenow}}"
}

{
  "action": "exit",
  "symbol": "MES1!",
  "time": "{{timenow}}"
}

{
  "action": "{{strategy.order.action}}",
  "symbol": "{{ticker}}",
  "quantity": "{{strategy.order.contracts}}",
  "market_position": "{{strategy.market_position}}",
  "prev_market_position": "{{strategy.prev_market_position}}",
  "position_size": "{{strategy.market_position_size}}",
  "prev_position_size": "{{strategy.prev_market_position_size}}",
  "time": "{{timenow}}",
  "order_id": "{{strategy.order.id}}"
}

Supported contracts: ES, MES, NQ, MNQ, RTY, M2K, YM, MYM, CL, MCL, NG, GC, MGC, SI, ZB, ZN, ZF, ZT, 6E, 6J, 6B, and the CME crypto futures BTC, MBT, ETH, MET, SOL, MSL, XRP and MXP. Anything outside that list is refused with a symbol-unknown message rather than guessed at.

• Market — the default. Sent as soon as the alert lands; fills at whatever the market gives you.
• Limit — set order_type to limit and give a limit_price. Rests until filled or cancelled.
• Stop — set order_type to stop and give a stop_price. Triggers into a market order.
• Stop-limit — set order_type to stop_limit and give both a stop_price and a limit_price.
• Bracket — include take_profit and/or stop_loss on an entry. Both legs rest at the broker as one group the instant the entry fills, and a fill on one cancels the other.
• Trailing stop — add trail_distance to a bracket. The stop leg becomes a trailing stop at the broker instead of a fixed one.

When a bracket is resting at the broker, the exit is already sitting there and does not depend on another alert arriving. That is the point of using one: your exit does not wait on TradingView.

• Paper — the rehearsal route, no broker login and nothing real at stake. Every order type, resting bracket, trailing stop and the running balance are simulated from your own alerts, so you can run the whole loop end to end before a live account is ever involved. The numbers are Shifu’s simulation, not a market feed: paper only sees a price when one of your alerts arrives, so a take-profit, stop or trail a broker would fill between two alerts is recorded at your next alert, and a strategy with a tight trail can look better on paper than on a broker account. Practice only sees prices when your alerts come in, so a limit or stop order on practice fills only when a later alert's price reaches it.
• Tradovate — the fullest route. Market, limit, stop and stop-limit entries, a resting take-profit and stop bracket, and a native trailing stop with an arm-after trigger all work, and your balance and open positions sync back into Shifu. You sign in on Tradovate’s own site and approve Shifu, so your password is never typed into Shifu. Pick Simulated or Live — most prop-firm accounts, funded ones included, run on Simulated.
• Rithmic — live and ready. Every order type, resting brackets, and a trailing stop with the same arm-after trigger (trail_trigger) Tradovate honours, following last trade rather than bid/ask. Two things to know: Rithmic does not flatten a prior position before a new entry, so send an explicit exit alert first if you need to be flat; and your balance and open positions live in your trading platform, not yet inside Shifu. You sign in with your Rithmic username, the system name your firm gave you (for example “Rithmic 01”), and your account number, each spelled exactly as your firm shows it — spaces and capitals included.
• ProjectX — the prop-firm route behind TopstepX. It is not built yet: the card in the account picker reads “coming” and is disabled, so there is nothing to connect or configure today. Firms that only sign in over ProjectX, such as TopstepX, are not supported today. Use paper or another route until then.
• NinjaTrader — not a separate route. NinjaTrader is both a platform and a brokerage (NinjaTrader Clearing, LLC also trades as Tradovate), so a NinjaTrader account reaches Shifu over either Tradovate or Rithmic, and the account picker asks the one question that settles it: a Tradovate or NinjaTrader username and password means Tradovate; a system name like “Rithmic 01” means Rithmic.

1. 1 · The bot picks a base size

   How to size each trade on the bot’s Settings tab decides where the number comes from. From the TradingView alert uses the alert’s quantity, and falls back to Default size when the alert leaves it out. Fixed contracts always uses Default size and ignores what the alert sent.

2. 2 · Each account applies its own rule

   On Account routing, an account is either on × alert, which multiplies the base size (1× is the same size, 2× is double), or on Contracts, which trades that exact number no matter what the alert says. Contracts is only offered when the bot is not sizing from the alert — a fixed count would contradict an alert-driven bot.

3. 3 · The result is rounded to whole contracts

   The scaled number is rounded, and never goes below one contract. Nothing is ever rounded down to zero and silently dropped.

The same alert can land as a different size on each account. Here one buy for 2 contracts is routed to three accounts, each with its own rule on the routing tab — the message never changes:

{
  "action": "buy",
  "symbol": "MES1!",
  "quantity": 2,
  "time": "{{timenow}}"
}

Shifu’s job is narrow on purpose: take the alert your script sends and place the matching order on the accounts you chose. It is not a strategy, not a risk manager, and not a second opinion. Everything it does is either delivering your order or a mechanical safeguard on the delivery itself.

Shifu will:

• Forward every valid alert to each account you routed the bot to, in the order your script fires them.
• Place market, limit, stop and stop-limit orders, and rest a take-profit and stop bracket at the broker when your alert carries one.
• Read the position your alert reports and turn a bare buy or sell into the right action, so a strategy you cannot edit still closes and flips correctly.
• Resolve a continuous symbol (MES1!, MNQ1!) to the current front month, so you never edit an alert at rollover.
• Write down every alert and every refusal on your Alerts page, with the exact message that caused it.

Shifu won’t:

• Decide whether a trade is a good idea, hold a signal back because it disagrees, or add a trade you did not send.
• Watch a daily loss limit, a drawdown, or your trading hours, or flatten you to protect an account — your prop firm enforces its own rules, and Shifu never pretends to be that layer.
• Give trading, sizing, or timing advice.
• Chase an entry. If a new trade’s hand-off to the broker does not land, it is skipped and recorded — never quietly sent again seconds later at a worse price. An exit is the exception: it keeps trying for a few seconds, because a late close beats an open trade.
• Send an alert to any account you did not route, or act on anyone else’s alerts. Multi-account means your own alert going to your own accounts, nothing more.

Shifu forwards what you send. The only things that stop an alert are mechanical: it is a duplicate, it is malformed, you paused the bot, you exceeded a limit you set, or routing it would leave your own accounts contradicting each other. Shifu never withholds an order because it disagrees with the trade.

• Duplicates — an exact repeat of the same alert (same time, same order or action, and the same position sizes when the alert sends them) counts as one. The second gets the same result as the first instead of a second fill.
• Runaway protection — a bot ignores alerts beyond its per-minute cap so a stuck script cannot machine-gun your account. On by default; you control the cap in the bot’s settings.
• Skip late entries (a bot’s Settings tab): pick Off, 5 s, 10 s, 15 s or 30 s. If TradingView takes longer than that to deliver an entry, Shifu skips it instead of trading late. Exits always go through, and skipped entries show as Arrived late on the Alerts list.
• Paused bot — a paused bot takes no new trades. It still sends its strategy’s exits, so an open trade closes when the strategy exits (a reverse only closes). Refused entries are recorded, so you can see the alert was fired and the bot was off.
• Paused account — a paused account, one you switch off in a bot, or one with Live routing off takes no new trades. By default a bot’s exit still closes a trade that bot opened there (a reverse only closes). If you pause accounts, or switch their routing off, to trade them by hand, turn off “Paused and routing-off accounts close bot trades” in Settings and those accounts skip every alert.
• Malformed messages — an alert that is not JSON, that is missing a required field, or that names a contract Shifu does not support is refused with the reason.
• Oversized messages — an alert message larger than 8 KB is refused.
• Conflicting accounts — when one bot routes to two or more accounts, Shifu will not send an order that would leave you long in one and short in another. The alert is refused and each account records why, so you can resync rather than discover a hedge later.

Every refusal is written to your Alerts page with the reason and the message that caused it, so nothing fails silently.