Stop Losses in

Stop losses in

Stop losses can be a confusing topic in The exact details of how they're executed aren't made clear in the documentation. And yet they're a critical part of testing your strategy, and a misunderstanding about execution can cost you your shirt.

Philosophically, is adversarial when it comes to execution. That is it tries to be as pessimistic as possible. The same applies to stop-losses. If a stop-loss and a take-profit get triggered inside the same bar, it will assume that the stop was triggered first, hence reducing our profits.

In order to simulate a super-simple example involving take-profits, the following is enough:

 1from backtesting import Backtest
 2from backtesting import Strategy
 3from backtesting.test import GOOG
 5class Strat(Strategy):
 7    def init(self):
 8        pass
10    # Step through bars one by one
11    def next(self):
12        price =[-1]
14        if self.position:
15            pass
16        else:
17            # Look at _Broker class for details on order processing
18            # What happens when we have sl and tp, etc.
19  , sl=price - 5, tp=price + 10)
21# might want trade_on_close = True to deal with gapping for sl and tp
22bt = Backtest(GOOG, Strat, cash=10_000)

If this looks like a load of nonsense to you I'd recommend checking out my beginners tutorial on All we're doing here is setting a take profit and stop loss a few dollars either side of the closing price when our buy is signalled. This particular detail is important when it comes to data with large gaps, like daily equities data that we're using here. Often the close price on one day and the open price on the next can be wildly different. Given that by default buys on the next days open, this can cause unexpected behaviour like exiting a trade much earlier than you'd expect.

If you're super interested in exactly how orders are processed, you may want to check out the _Broker class inside the file on the Github.

Trailing Stop Losses

The above example isn't overly interesting because you can only set a fixed stop loss at the time you make the trade. In the real world you might want to move your stop loss based on the price action that you're seeing.

Built-in Trailing Stop Loss

Backtesting.lib has a built in trailing stop loss strategy class that we can use to create new strategies. There's an example in the docs. Here we're using a simple RSI strategy and setting a trailing stop loss at stop_range multiplied by the ATR, which is what the TrailingStrategy uses to calculate the new stop-loss on each bar.

 1from backtesting import Backtest
 2from backtesting import Strategy
 3from backtesting.test import GOOG
 4from backtesting.lib import crossover, TrailingStrategy
 6import ta
 8def RsiIndicator(close, window):
 9    rsi = ta.momentum.RSIIndicator(close, window=window)
10    return rsi.rsi()
12class RsiOscillator(TrailingStrategy):
13    """
14    Buy when we cross the lower bound to the upside
15    hold until we get stopped out
16    """
18    rsi_window = 14
19    lower_bound = 70
20    stop_range = 10
22    def init(self):
23        super().init()
24        super().set_trailing_sl(self.stop_range)
25        self.rsi = self.I(RsiIndicator,, self.rsi_window)
27    def next(self):
28        super().next()
30        if len(self.trades) == 0:
31            if crossover(self.rsi, self.lower_bound):
34bt = Backtest(GOOG, RsiOscillator, cash = 10_000, commission=0.002)
36stats =
37        rsi_window = 21,
38        lower_bound = 40,
39        stop_range = 5,
40        )

Custom Trailing Stop Loss

TrailingStrategy is cool and all, but it'd be really nice to be able to implement a trailing stop loss that didn't have to use some multiple of the ATR. To fix this, we can of course just implement our own version of TrailingStrategy, which I attempt below.

 1from backtesting import Backtest
 2from backtesting import Strategy
 3from backtesting.test import GOOG
 4from backtesting.lib import crossover
 6class TrailingStrategy(Strategy):
 8    __sl_amount = 6.
10    def init(self):
11        super().init()
13    def set_trailing_sl(self, sl_amount: float = 6):
14        """
15    Set the trailing stop loss as $n below the current price (for long positions)
16        Works for future bars only
17        """
18        self.__sl_amount = sl_amount
20    def next(self):
21        super().next()
22        # Can't use index=-1 because self.__atr is not an Indicator type
23        index = len(
25        for trade in self.trades:
26            if trade.is_long:
27       = max( or -np.inf,
28                     [index] -  self.__sl_amount)
29            else:
30       = min( or np.inf,
31                     [index] +  self.__sl_amount)

In my example here I've edited TrailingStrategy to simply set the trailing stop loss at sl_amount below the current closing price.

After you've written your own TrailingStrategy, you can use the same strategy as above, inheriting from your new TrailingStrategy class.

Video Tutorial

If you're still a little unsure after reading through this post, here's the video version of this tutorial: