--- title: "Multiple Take Profit Levels Automation: What Each Fill Sends" slug: multiple-take-profit-levels-automation-what-each-fill-sends date: 2026-09-25 modified: 2026-09-25 author: Bhavishya Goyal excerpt: "" meta_description: "One TradingView alert can open 3 exit legs on Tradovate, yet a strategy\'s own exit fill can flip you short. What each fill sends." focus_keyword: multiple take profit levels automation canonical_url: "https://blog.pickmytrade.trade/multiple-take-profit-levels-automation-what-each-fill-sends/" og_title: "Multiple Take Profit Levels Automation: What Each Fill Sends" og_description: "One TradingView alert can open 3 exit legs on Tradovate, yet a strategy\'s own exit fill can flip you short. What each fill sends." og_image: "https://blog.pickmytrade.trade/wp-content/uploads/2026/09/Gemini_Generated_Image_dawqrkdawqrkdawq-1024x572.avif" schema_type: FAQPage categories: - Trading Automation - TradingView - Tradovate tags: [] reading_time: 19 word_count: 4461 robots: "index, follow" lang: en-US --- # Multiple Take Profit Levels Automation: What Each Fill Sends Multiple take profit levels automation looks like a settings problem. You pick three targets, split the contracts, paste one JSON into TradingView and you’re done. Then your strategy’s own exit fires on a Tuesday afternoon, and the account that should be flat is short five contracts. Table of Contents 1. [Where can multiple take-profit levels live?](https://blog.pickmytrade.trade/#where-can-multiple-take-profit-levels-live) 2. [What does one alert with three exit legs actually send?](https://blog.pickmytrade.trade/#what-does-one-alert-with-three-exit-legs-actually-send) 3. [The sizing rules the generator enforces](https://blog.pickmytrade.trade/#the-sizing-rules-the-generator-enforces) 4. [What the numbers in dollar_tp mean](https://blog.pickmytrade.trade/#what-the-numbers-in-dollar_tp-mean) 5. [What happens when your strategy’s own exit fires?](https://blog.pickmytrade.trade/#what-happens-when-your-strategys-own-exit-fires) 6. [A Pine pattern that sends close on exits](https://blog.pickmytrade.trade/#a-pine-pattern-that-sends-close-on-exits) 7. [What about indicator alerts on Tradovate?](https://blog.pickmytrade.trade/#what-about-indicator-alerts-on-tradovate) 8. [How to automate Pine Script partial exits instead](https://blog.pickmytrade.trade/#how-to-automate-pine-script-partial-exits-instead) 9. [What you give up](https://blog.pickmytrade.trade/#what-you-give-up) 10. [Which brokers support multiple take profit levels automation?](https://blog.pickmytrade.trade/#which-brokers-support-multiple-take-profit-levels-automation) 11. [Does splitting the exit improve your results?](https://blog.pickmytrade.trade/#does-splitting-the-exit-improve-your-results) 12. [Why split at all](https://blog.pickmytrade.trade/#why-split-at-all) 13. [A warning for backtests](https://blog.pickmytrade.trade/#a-warning-for-backtests) 14. [Why the PickMyTrade docs seem to disagree](https://blog.pickmytrade.trade/#why-the-pickmytrade-docs-seem-to-disagree) 15. [What should you test before going live?](https://blog.pickmytrade.trade/#what-should-you-test-before-going-live) 16. [Frequently Asked Questions](https://blog.pickmytrade.trade/#frequently-asked-questions) 17. [Which setup should you pick?](https://blog.pickmytrade.trade/#which-setup-should-you-pick) Nothing malfunctioned: the alert did exactly what its flags told it to. The trouble is that “one alert, three targets” only describes the entry. Every later fill sends its own message, and the setup that works for one kind of strategy quietly breaks another. This guide follows each of those messages. It picks up where our earlier overview of [multiple take-profit levels from one TradingView alert](https://blog.pickmytrade.trade/multiple-take-profit-levels-tradingview-alert/) stopped. That post covers the JSON walkthrough, so here we look at what happens after the entry fills. > **Key Takeaways** > > > > > > > > - PickMyTrade’s multi-leg JSON splits one entry into exit legs with their own contracts, target and stop, but only on Tradovate and only with a fixed contract count. > - PickMyTrade’s own flag table says that under the workaround’s flags (pyramid off, reverse on), a flat strategy’s exit re-opens a position the other way. > - In a fair market, a 2/2/1 split at +10/+15/+20 points has the same expected value as one target. It changes the mix of trades, not the edge. ## Where can multiple take-profit levels live? {#where-can-multiple-take-profit-levels-live} There are 3 places your take-profit levels can sit: at the broker as resting orders, inside your Pine Script strategy, or in separate alerts you build yourself. Each one changes who holds the stop, how many webhooks fire per trade, and whether the contract count can follow your strategy’s sizing. Most confusion starts because people mix two of them. The table below is our map. | | Broker legs | Pine exits | Close alerts | | --- | --- | --- | --- | | Targets rest | At the broker | In Pine | In the indicator | | Stop rests | At the broker | In Pine | Wherever you put it | | Webhooks per trade | 1 | 1 per fill | 1 per alert | | Quantity source | Fixed in the JSON | Your strategy | Fixed per alert | | Brokers | Tradovate only | All | All, with limits | **Broker legs** (`advance_tp_sl`) means the entry order carries several exit groups, each with its own contracts, target and stop. **Pine exits** means your strategy calls `strategy.exit()` several times, and each fill fires its own webhook. **Close alerts**, the third route, mostly exist for indicators on brokers that can’t hold several brackets. Where the stop sits matters most. A stop resting at the broker still works through a TradingView outage, while one that lives in Pine Script exists only as long as the alert pipeline does. What happens to yours if an alert never arrives? ## What does one alert with three exit legs actually send? {#what-does-one-alert-with-three-exit-legs-actually-send} One webhook carries the whole plan: a `quantity` of 5 plus an `advance_tp_sl` array of 3 blocks sized 2, 2 and 1. That’s the example in PickMyTrade’s [multiple TP/SL strategy workaround](https://docs.pickmytrade.trade/docs/pickmytrade-multiple-tp-sl-strategy-workaround/), last updated September 3, 2026. Each block closes its own contracts at its own target. **advance_tp_sl** is the JSON array that holds those exit groups. Every block carries its own `quantity`, take profit, stop loss, breakeven and trailing fields, so leg 3 can trail while leg 1 just sits on a fixed target. The [advanced trading features page](https://docs.pickmytrade.trade/docs/pickmytrade-advanced-trading-features/) walks through a 7-contract version split 4 and 3. Here’s the shape of the documented example, trimmed to the fields that matter: ``` { "symbol": "MNQ1!", "data": "{{strategy.order.action}}", "quantity": 5, "pyramid": false, "same_direction_ignore": false, "reverse_order_close": true, "order_type": "MKT", "advance_tp_sl": [ { "quantity": 2, "dollar_tp": 10, "dollar_sl": 10, "breakeven": 0, "trail": 0 }, { "quantity": 2, "dollar_tp": 15, "dollar_sl": 10, "breakeven": 0, "trail": 0 }, { "quantity": 1, "dollar_tp": 20, "dollar_sl": 10, "breakeven": 0, "trail": 0 } ] } ``` The real template has more zeroed fields per block. Don’t hand-edit the array. The docs say to leave `advance_tp_sl` and `multiple_accounts` as generated and change only the `data` line. One alert, three exit legs on MNQ Price ladder for a 5-contract MNQ long split 2, 2 and 1. Entry at zero. Every leg shares a stop at minus 10 points. Leg 1 takes 2 contracts off at plus 10 points, worth 40 dollars. Leg 2 takes 2 off at plus 15, worth 60 dollars. Leg 3 takes the last contract at plus 20, worth 40 dollars. If the stop hits before any target, all 5 contracts lose 10 points, 100 dollars in total. If all three targets fill, the trade makes 140 dollars. MNQ pays 2 dollars per point per contract. One alert, three exit legs on MNQ 5 contracts split 2 / 2 / 1, one shared 10-point stop. MNQ pays $2 per point per contract. +20 +15 +10 Entry −10 Points +$40 −$40 Leg 1 2 contracts +$60 −$40 Leg 2 2 contracts +$40 −$20 Leg 3 1 contract All three targets: +$140. Stop before TP1: −$100. The generator refuses the alert unless 2 + 2 + 1 equals the total, 5. The documented 2/2/1 example on MNQ. Each leg closes its own contracts at its own target, and all three share the 10-point stop. *The documented 2/2/1 example on MNQ. Each leg closes its own contracts at its own target, and all three share the 10-point stop.* ### The sizing rules the generator enforces {#the-sizing-rules-the-generator-enforces} We analyzed the alert generator’s code to see what it will and won’t let through. Three rules came out of it, and none of them is spelled out on the docs page. - The “Add multiple tp/sl” button only appears when the alert sizes by **quantity** and has stop loss and take profit switched on. In risk-percentage mode it isn’t offered at all. - The legs must add up to the total. If they don’t, it refuses with: “Please make sure your total quantity matches the combined quantity set in the advanced TP/SL allocations before generating the alert.” - The “Add TP/SL” button disappears once the legs cover the full quantity, so you can’t add an empty fourth leg. That fixed total is the price of the feature. The workaround page says it plainly: PickMyTrade uses the quantity in the alert JSON and ignores your strategy’s quantity. A strategy that sizes by volatility or account equity will keep sending 5, whatever it calculated. It also sets a floor. You need at least as many contracts as legs, because futures trade in whole contracts. A single MNQ can’t be split; two gives you 1 and 1; three is the smallest size that fits three targets. ### What the numbers in dollar_tp mean {#what-the-numbers-in-dollar_tp-mean} Despite the name, `dollar_tp: 10` in the documented example means 10 points of price, not 10 dollars, which is $20 per contract on MNQ. Type ticks into the generator and its code multiplies them by the tick size. The result lands in those same fields, so the JSON always carries a price distance. So the 2/2/1 plan risks 10 points on 5 contracts: $100 on MNQ and $1,000 on NQ. Check the dollar risk the generator displays before you copy anything. Is it the number you had in mind? The same unit rule applies to each leg’s breakeven, which our [breakeven offset tick math](https://blog.pickmytrade.trade/breakeven-offset-tradovate-move-your-stop-after-x-ticks/) covers in detail. Trailing legs follow the step model in our [auto trail stop math](https://blog.pickmytrade.trade/auto-trail-stop-futures-math-trigger-distance-frequency/). ## What happens when your strategy’s own exit fires? {#what-happens-when-your-strategys-own-exit-fires} Under the workaround’s flags, every buy or sell closes the open position, then opens a fresh 5-contract trade in its direction. The [JSON configuration reference](https://docs.pickmytrade.trade/docs/tradingview-json-alert-configuration/) states this in its pyramid table: with reverse on and pyramid off, “A new trade opens if not a close signal.” Now remember what a strategy alert is. **Order fill alerts** are the messages TradingView sends every time the strategy’s simulated broker fills an order, and they fire immediately. The alert box holds one message, so every fill sends the same JSON: entries, exits, stops, the lot. And that JSON says `"data": "{{strategy.order.action}}"` with `"quantity": 5` and three legs. An exit from a long is a `sell`, which is the same thing the next short entry sends. PickMyTrade can’t tell the two apart, and the table above says what it does with a sell. What the exit fill sends under the workaround flags Four strategy shapes under PickMyTrade’s workaround JSON, with pyramid false and reverse_order_close true. Stop-and-reverse: the opposite fill closes the leftover and opens a fresh short with three legs, as intended. Flat strategy: its own exit closes the leftover, then opens an unwanted short. Pine partial exits: the first partial fill closes all 5 contracts and opens a 5-lot short. Entries only: nothing is sent, so TradingView skips the next same-direction entry. What the exit fill sends Workaround JSON: quantity 5, pyramid false, reverse_order_close true, data {{strategy.order.action}}. Stop-and-reverse strategy Works Opposite signal fills → sends: sell, qty 5, three legs Closes what’s left, opens a fresh short with three legs The shape the documented example fits. Flat strategy, Pine exit Breaks strategy.close fills → sends: sell, qty 5, three legs Closes what’s left, then opens a short nobody asked for Fix: send close on exits (Pine example below). Pine partial exits Breaks TP1 fills, Pine sells 2 → sends: sell, qty 5, three legs Closes all 5 at market, opens a 5-lot short Fix: use Multiple Exits mode instead. Entries only, no exits Drifts Broker legs flatten you → sends: nothing Next same-side signal is skipped by TradingView Fix: give the strategy the same exits as the legs. What each strategy shape sends under the workaround’s flags. Only the stop-and-reverse row behaves as intended without changes. *What each strategy shape sends under the workaround’s flags. Only the stop-and-reverse row behaves as intended without changes.* Here’s what that flag table implies for four strategy shapes: | Your strategy | What the exit fill sends | What happens | | --- | --- | --- | | Stop-and-reverse, always in | sell, 5, three legs | Leftovers close, a new short opens with its legs | | Flat between trades, own exit | sell, 5, three legs | Leftovers close, then an unwanted short opens | | Pine partial exits (sell 2, 2, 1) | sell, 5, three legs | All 5 close at market, a 5-lot short opens | | Entries only, no exits | Nothing | TradingView still thinks you’re long | The first row is the case the documented example quietly assumes. A stop-and-reverse strategy only ever sends the next entry, so “close and reverse” is exactly right. The other three rows need a different setup. The last row fails more quietly: broker legs can close the whole position while TradingView’s copy of the strategy stays long. With the default pyramiding of 1, TradingView then ignores the next long signal, since it thinks you’re already in. You miss the trade and get no error message. These rows follow from the documented flags, not from a live run of each one, so test the row that matches your strategy on a demo account before you rely on it. ### A Pine pattern that sends close on exits {#a-pine-pattern-that-sends-close-on-exits} For a strategy that goes flat between trades, give each order its own message. Pine’s `alert_message` argument lets an entry send the multi-leg JSON while the exit sends a plain close. In PickMyTrade, a close alert closes all open positions and cancels open orders without opening anything new. ``` //@version=6 strategy("Multi-TP entry, close on exit", overlay = true) buyJson = input.text_area("", "PickMyTrade BUY alert JSON") sellJson = input.text_area("", "PickMyTrade SELL alert JSON") closeJson = input.text_area("", "PickMyTrade CLOSE alert JSON") // alert_message text skips TradingView's placeholders, so fill the two the JSON uses fill(string json) => stamp = str.format_time(timenow, "yyyy-MM-dd'T'HH:mm:ss'Z'", "UTC") str.replace_all(str.replace_all(json, "{{close}}", str.tostring(close)), "{{timenow}}", stamp) fast = ta.ema(close, 9) slow = ta.ema(close, 21) goLong = ta.crossover(fast, slow) goShort = ta.crossunder(fast, slow) exitL = ta.crossunder(close, slow) exitS = ta.crossover(close, slow) if strategy.position_size == 0 and goLong strategy.entry("L", strategy.long, alert_message = fill(buyJson)) if strategy.position_size == 0 and goShort strategy.entry("S", strategy.short, alert_message = fill(sellJson)) if strategy.position_size > 0 and exitL strategy.close("L", alert_message = fill(closeJson)) if strategy.position_size 0 e = strategy.position_avg_price strategy.exit("TP1", "L", qty = 2, limit = e + 10, stop = e - 10) strategy.exit("TP2", "L", qty = 2, limit = e + 15, stop = e - 10) strategy.exit("TP3", "L", qty = 1, limit = e + 20, stop = e - 10) ``` Call order matters. The first `strategy.exit()` reserves its contracts first, so a later call can only exit what’s left. Use `qty` rather than `qty_percent` when the split has to come out in whole contracts, and read the List of Trades to confirm the sizes you expected. Pair it with the default strategy alert: `{{strategy.order.action}}` for direction and `{{strategy.order.contracts}}` for size, the strategy JSON shown in the configuration reference. The [strategy automation guide](https://docs.pickmytrade.trade/docs/automate-tradingview-strategies/) covers the Multiple Exits choice itself. Then a TP1 fill sends `sell 2`, and the long drops from 5 to 3. ### What you give up {#what-you-give-up} This route costs you two things, and both come from where the orders live: 1. **The stop lives in TradingView.** Nothing rests at the broker. If an alert fails to deliver, the position has no protection until you step in. 2. **Targets arrive as market orders.** TradingView fills its limit on the chart, then the webhook sends a market exit, so a fast move can cost you a tick or two versus a resting limit. Also watch the stop-out: each leg carries its own stop, so a hit can come through as up to three sells on the same bar. Keep `same_direction_ignore` off for these alerts, and make sure nothing between TradingView and the broker filters repeats. Our [duplicate webhook guide](https://blog.pickmytrade.trade/duplicate-webhook-alerts-why-your-bot-double-orders-2026/) covers where those filters hide. ## Which brokers support multiple take profit levels automation? {#which-brokers-support-multiple-take-profit-levels-automation} ![A trader lit in blue light works at a laptop and a tablet, both showing candlestick charts and order panels.](https://images.pexels.com/photos/18706593/pexels-photo-18706593.jpeg?auto=compress&cs=tinysrgb&w=1200&fm=webp) Broker-side legs from a single alert work on 1 PickMyTrade connection: Tradovate. Every other broker gets multiple take profit levels automation through Pine partial exits, or through separate alerts. We analyzed the alert generator of the app that serves Rithmic, ProjectX, Interactive Brokers and the rest, and `advance_tp_sl` doesn’t appear anywhere in its code. | Broker | Legs from one alert | Pine partial exits | | --- | --- | --- | | Tradovate | Yes | Yes | | Rithmic | No | Yes | | ProjectX / TopstepX | No, one TP and one SL per symbol | Yes | | TradeLocker | Not yet | Yes | | Interactive Brokers | Varies by routing and account | Yes | The ProjectX line comes from PickMyTrade’s own [FAQ](https://docs.pickmytrade.trade/docs/faqs/). It’s also why stacked brackets on TopstepX can leave orders behind, which our look at [TopstepX OCO brackets](https://blog.pickmytrade.trade/oco-brackets-topstepx/) digs into. Tradovate itself has one more boundary: the [manual Trade Copier](https://docs.pickmytrade.trade/docs/tradingview-to-tradovate-trade-copier/) doesn’t copy multi-target orders. Place Target #1 and Target #2 by hand, and linked accounts get only a single take profit and stop. Automated alerts to several accounts are a different path. What about indicators on a broker without legs? The FAQ suggests a separate close alert per target, fired from the indicator as price reaches each level. Be careful there: a plain close alert flattens the whole position. Closing part of it takes comment-tagged entries, and that targeted partial close works for indicator alerts only. ## Does splitting the exit improve your results? {#does-splitting-the-exit-improve-your-results} In a fair market it doesn’t. A 5-contract MNQ trade split 2/2/1 at +10, +15 and +20 points, with a 10-point stop, has an expected gross result of exactly $0, the same as one target at +15. What the split changes is how often you win, how much, and how far results swing from trade to trade. We ran the closed-form math for a fair random walk, where price is as likely to tick up as down, and checked every plan with 40,000 simulated trades. The simulations landed within a third of a point of zero every time. Here’s the mix each plan produces: Same expected value, different trades Outcome mix for three exit plans on a 5-contract MNQ long with a 10-point stop, in a fair random walk. One target at plus 15: 60 percent lose 100 dollars, 40 percent make 150. The 2, 2, 1 split at plus 10, 15 and 20: 50 percent lose 100, 10 percent fill the first target and still lose 20, 6.7 percent make 80, 33.3 percent make 140. The same split with breakeven after the first target: 50 percent lose 100, 16.7 percent make 40, 8.3 percent make 100, 25 percent make 140. Green trades are 40, 40 and 50 percent. The standard deviation of trade results is 122, 110 and 105 dollars. Expected gross profit is zero in all three. Same expected value, different trades 5 MNQ contracts, 10-point stop, fair random walk. Expected gross P&L is $0 in every row. One target, 5 lots at +15 60% −$100 40% +$150 Green trades 40% | spread of results $122 2 / 2 / 1 at +10 / +15 / +20 50% −$100 33.3% +$140 10% −$20 6.7% +$80 Green trades 40% | spread of results $110 Same split, breakeven after TP1 50% −$100 16.7% +$40 25% +$140 8.3% +$100 Green trades 50% | spread of results $105 Closed-form math, checked with 40,000 simulated trades per plan. Our closed-form outcome math for a fair random walk, checked with 40,000 simulated trades per plan. Fees are excluded and equal across plans. *Our closed-form outcome math for a fair random walk, checked with 40,000 simulated trades per plan. Fees are excluded and equal across plans.* The middle row holds the surprise: the first target fills on half of all trades, yet only 40% of trades finish green. One in five TP1 fills still ends red, because 2 contracts bank 10 points while 3 contracts give back 10 points at the stop. That’s a $20 loss on a trade where a target filled. Add breakeven on legs 2 and 3 once TP1 fills, and green trades rise to 50%. Nothing is free, though: runs to the last target drop from 33.3% of trades to 25%. The spread of results also narrows, from $122 per trade with one target to $105 with the split plus breakeven. ### Why split at all {#why-split-at-all} For most futures traders, the shape of the results matters more than the average. Prop firm consistency rules cap how much of your profit one day can hold, and daily loss limits punish long losing streaks. A narrower spread helps with both, which our guides to the [prop firm consistency rule](https://blog.pickmytrade.trade/the-prop-firm-consistency-rule-explained/) and [daily loss limits a bot respects](https://blog.pickmytrade.trade/daily-loss-limit-on-tradovate-setting-one-a-bot-respects/) explain. Commissions don’t change either. Tradovate charges per contract, so 5 contracts cost the same whether they leave in one order or three. On MNQ that’s $9.50 a round turn at the Free plan’s all-in rate of $0.95 per side. ### A warning for backtests {#a-warning-for-backtests} In our July to September 2026 sample, the median regular-hours 5-minute MNQ bar spanned about 31 points. That’s about as wide as the whole 30-point range from the stop to TP3, so all three legs can trigger inside a single bar. The backtest then has to guess the order, so don’t trust a bar-level test of a plan this tight. ## Why the PickMyTrade docs seem to disagree {#why-the-pickmytrade-docs-seem-to-disagree} You’ll find pages that seem to contradict the workaround, and it helps to know which one wins. The FAQ answer on multiple take-profit levels, dated November 7, 2025, says “Tradovate does not support multiple TP levels from a single TradingView strategy alert.” The workaround page was published a month later, on December 9, 2025, and updated on September 3, 2026. The newer page and the app itself are the current state. The older FAQ line described how things stood before the workaround existed. Three more details trip people up: - The strategies guide lists the partial exit strategy with TP/SL “Currently Unsupported”. That means PickMyTrade won’t attach broker targets to a strategy that already sends its own exits, which is the Multiple Exits rule again. - The workaround says to pick **Indicator** as the alert type, even though the JSON goes into a strategy alert. You build an indicator-style JSON with fixed legs, then swap the `data` line so the strategy supplies direction. - The FAQ’s example splits a 2-contract entry into 1, half and half. Futures can’t trade half a contract, so read it as 2, 1 and 1 on a 4-contract entry. A fourth one is worth knowing too. The FAQ says `reverse_order_close` “should be used only with indicator-based alerts”, while the workaround ships it as true inside a strategy alert. Both hold once you see the workaround JSON as an indicator JSON running on a strategy’s signals. ## What should you test before going live? {#what-should-you-test-before-going-live} Run at least 3 complete trade cycles on a Tradovate demo before any live contract sees the alert. Make one reach every target, stop one out before TP1, and let your strategy exit the third mid-trade. For the account side, see [testing a strategy on Tradovate demo](https://blog.pickmytrade.trade/tradovate-demo-trading-test-a-strategy-before-you-fund-it/). - Match your strategy to one row of the four-shape table, and pick the setup that row calls for. - Check that the legs add up to the total. - Hold at least one contract per leg, since futures don’t trade in fractions. - Compare the dollar risk the generator shows with your own math: points × point value × contracts. - After each cycle, put the broker’s position next to the strategy’s position in TradingView. They should agree. - Look for working orders left behind after any close, and cancel strays before the next signal. If the broker and TradingView ever disagree after an exit, stop there and fix the setup. Every later signal inherits that mismatch. Why stack new trades on a position you can’t explain? ## Frequently Asked Questions {#frequently-asked-questions} **Can one TradingView alert set multiple take-profit levels?** Yes, on Tradovate: PickMyTrade’s `advance_tp_sl` array lets one alert open a position with separate exit legs, such as 2, 2 and 1 contracts at +10, +15 and +20 points. Each leg carries its own target, stop, breakeven and trail. On other brokers, code the partial exits in Pine and send one alert per fill. **How many contracts do I need for three take-profit levels?** At least 3, because each leg needs a whole contract and futures can’t be split. One MNQ contract can’t scale out at all. The generator also requires the legs to add up exactly to the total, so a 5-contract alert split 2/2/1 passes, while 2/2/2 on 5 contracts is refused. **Does multiple take profit levels automation work on Rithmic or TopstepX?** Yes, but only through Pine partial exits, not broker legs from one alert. The multi-broker generator has no `advance_tp_sl` option, and ProjectX and TopstepX allow 1 take profit and 1 stop per symbol. Code each target with `strategy.exit()`, then choose Multiple Exits mode when you generate the alert. **Why did my account go short after my strategy exited?** PickMyTrade’s flag table says that with pyramid off and reverse on, every `sell` closes the open position and then opens a new short. A flat strategy’s exit sends `sell` with the full 5-contract quantity and three legs. Send a close alert on exits instead, using `alert_message`, or use `{{strategy.market_position}}` after testing it on demo. **Can the exit legs use my strategy’s position size?** No: the workaround hardcodes every quantity, and PickMyTrade ignores the size your Pine strategy calculates. Sizing by equity or volatility never reaches the broker. Regenerate the alert whenever your size changes, or move the targets into Pine so `{{strategy.order.contracts}}` carries the real size of each fill. ## Which setup should you pick? {#which-setup-should-you-pick} Match the setup to how your alert exits, because 4 exit styles need 4 different alert setups. That one choice decides whether multiple take profit levels automation behaves or quietly flips your position: - **Stop-and-reverse on Tradovate:** use the workaround JSON as documented. It’s the case it was built for. - **Flat strategy on Tradovate:** keep the legs, and send a close on exits with the `alert_message` pattern above. - **Targets already in Pine, any broker:** use Multiple Exits mode and the default strategy JSON. - **Indicator alerts on Tradovate:** use Multiple TP/SL with `same_direction_ignore` on. Whichever you choose, prove it on demo first, then check the broker’s position against TradingView after every exit. Start with the [7-day free trial with no credit card](https://pickmytrade.trade/pages/pricing/) via the [Tradovate automation page](https://pickmytrade.trade/tradovate-automation/). You can read more [about the PickMyTrade team](https://pickmytrade.trade/pages/about/), or [contact us](https://pickmytrade.trade/pages/contact-us/) if your exits behave differently from what’s described here. _**Disclaimer:** This content is for informational purposes only and does not constitute financial, investment, or trading advice. Trading and investing in financial markets involve risk, and it is possible to lose some or all of your capital. Always perform your own research and consult with a licensed financial advisor before making any trading decisions. The mention of any proprietary trading firms, brokers, does not constitute an endorsement or partnership. Ensure you understand all terms, conditions, and compliance requirements of the firms and platforms you use._ --- Also Checkout: [Connect Tradovate with Trading view using PickMyTrade](https://blog.pickmytrade.trade/connect-tradovate-with-trading-view-using-pickmytrade/) For AI tools & developers:[View Markdown →](https://blog.pickmytrade.trade/multiple-take-profit-levels-automation-what-each-fill-sends.md)