Bot feature - Panic sell

Would it be possible to add Panic Sell option in bot settings, with the same behaviour as the current Close Deals in the opened deals’ options?

Unlike TP or SL, Panic Sell is not a price-based exit. It is an execution failsafe that forces immediate liquidation, bypassing all strategy and market logic. This makes it critical in situations where TP/SL cannot execute (exchange lag, extreme volatility, stuck orders).

Having Panic Sell available would:

  • Provide a true emergency exit
  • Reduce manual intervention
  • Improve risk control when execution reliability matters more than price

just adding more info to this feature suggestion to explain the logic and why panic sell is different from a standard sell order.

Why Panic Sell Often executes faster or more fully than a normal order

Panic Sell prioritises execution logic, not price logic

A regular market order just gets sent once to the exchange and waits to be matched with existing orders. It may execute immediately if there’s liquidity, but if the exchange is slow, congested, or price is moving fast, the order can lag, get partial fills, or even fail temporarily.

A Panic Sell feature (like in bots or some exchanges) often does more than “send a single market order” — it aggressively:

  • Cancels pending orders
  • Re-submits sell orders repeatedly
  • Uses fallback logic (e.g., progressively worse pricing)
    …until the position is closed.

This is execution logic, not strategy logic — it forces the exit as quickly as possible, even if the price is not ideal.


Market orders can still be delayed by market conditions

Even with market orders:

  • Exchanges need to route the order to the matching engine
  • Liquidity must exist at each price level
  • Network or API lag can introduce delays

In volatile conditions (thin order book, rapid price moves), your market order might not fill instantly, because it’s actually being matched step by step against resting orders in the book and might wait if there’s no liquidity.

Panic Sell implementations often keep retrying and chunking orders until filled — which makes it appear faster in practice, because it doesn’t give up or wait passively.