7 well-known chart patterns, backtested and ranked

Profit factor is the money won divided by the money lost. Above 1 means the test made money. Max drawdown is the biggest fall from the highest balance. 2019–2022 and 2023–2025 show the result in each period on its own. Monte Carlo drawdown: we shuffled the trades into a random order 1,000 times; in 95% of those runs, the worst drawdown was this number or less. Result is the change in the account, with the risk of each trade set to 1% of the account at that time.

No, not with the usual breakout rules, in our backtest. We traded 7 well-known chart patterns on 10 markets (5 currency pairs, gold and 4 stock indices), from 2019 to 2025, after trading costs. Each market was tested on 1-hour, 4-hour and daily charts. Each trade risked 1% of the account, an amount we call 1R. Traded together, the patterns lost 0.009R per trade over 7,503 trades. On daily charts they made +0.087R per trade, but over only 254 trades. Traded alone, the symmetrical triangle made +0.125R per trade and the wedges lost 0.040R. The sell forms of all 7 patterns, like the double top and the head and shoulders, lost money, in years when most of these markets rose. Waiting for price to come back to the breakout line made +0.039R per trade, or +0.021R without the trades where price only touched the order.

No pattern was clearly best in our backtest of 7 chart patterns on 10 markets, from 2019 to 2025, after trading costs. Each trade risked 1% of the account, an amount we call 1R. The symmetrical triangle made the most per trade, +0.125R over 542 trades, but none of its tests had the 100 trades we need to judge a test. Most of that came from upside breakouts: +0.272R per trade, compared with −0.023R for downside breakouts. Double tops and bottoms won most often, 59.0% of their trades, but lost 0.005R per trade, because their take-profit was usually closer than their stop-loss. The wedges did worst: −0.040R per trade over 3,271 trades.

In our backtest, 7 chart patterns traded together won 41.0% of their 7,503 trades, from 2019 to 2025 on 10 markets. A win is a trade that made money after trading costs. The win rate depended on how far away the take-profit was. Double tops and bottoms won most often, 59.0%: for half of their trades, the take-profit was less than 0.78 times the distance to the stop-loss. Flags won least often, 23.4%: their target is the whole move before the flag, for half of the trades more than 3.47 times the distance to the stop-loss. A higher win rate did not mean more money: the flags made a small profit and the double tops and bottoms a small loss.

Yes, a little, in our backtest of 7 chart patterns on 10 markets, from 2019 to 2025. After a candle closed beyond the pattern's breakout line, we placed a limit order (an order that waits at a set price) at that line for up to 10 candles. Of the 7,965 orders, 6,375 filled. Each trade risked 1% of the account, an amount we call 1R. The patterns then made +0.039R per trade, compared with −0.009R when we entered at the next candle's open. With the retest, 19 of 30 tests made money, compared with 14. But a backtest fills a limit order as soon as price touches it. Without the 630 trades where price went less than one spread past the order, the retest made +0.021R per trade. Waiting for a second close beyond the line did not help much: the average trade still lost 0.003R, and only 10 of 30 tests made money.

This is the exact code from the BacktestingMax strategy engine. Paste it into the strategy editor in the app to run it on any market.

class ChartPatterns(Strategy):
    """The common chart patterns, found from swing points, each traded with the same entry and exit.
    Swing points: a swing high is a candle whose high is higher than the highs of the 3 candles
    before it and the 3 candles after it (a tie doesn't count), the rule of the engine's pivot
    helper. A swing low is the mirror. A swing is known 3 candles after it, when those candles have
    closed. Highs and lows take turns: if two swing highs come without a swing low between them,
    only the higher one counts (two lows: only the lower one).
    'About the same price' and 'flat' mean that two swings differ by at most 15% of the pattern's
    height (tolerance = 0.15); 'rising' and 'falling' mean by more. The patterns, bearish form
    first (the bullish form is the mirror image):
      1 double top           the newest swing high and an earlier one at about the same price, at
                             most 60 candles apart, with every swing high between them lower than
                             both. Sell below the lowest swing low between them. Height: the higher
                             top to that low. Double bottom: the mirror.
      2 head and shoulders   5 swings in a row: left shoulder, low, head, low, right shoulder. The
                             head is the highest, the shoulders at about the same price and above
                             the neckline, the line through the two lows. Sell below the neckline.
                             Height: the head to the neckline. Inverse: the mirror.
      3 descending triangle  2 highs and 2 lows in a row: falling highs, flat lows. Sell below the
                             lower line. Ascending triangle: the mirror (buy above the upper line).
      4 symmetrical triangle falling highs and rising lows. Buy above the upper line or sell below
                             the lower line, whichever comes first.
      5 bear flag            4 swings in a row: high, low (the fall between them is the pole), a
                             bounce of at most half the pole, then a higher low. Sell below the
                             line through the two lows. Height: the pole. Bull flag: the mirror.
      6 rising wedge         2 highs and 2 lows in a row: rising highs and rising lows, the lows
                             rising faster, so the lines meet. Sell below the lower line. Falling
                             wedge: the mirror.
      7 cup and handle       the cup: two swing highs at about the same price (the rims), at most
                             60 candles apart, every swing high between them lower than both. It
                             must be rounded: more than half of the candles between the rims close
                             in the cup's lower half. The handle: the next swing low, at most half
                             the cup's depth below the right rim. Buy above the right rim. Height:
                             the right rim to the cup's lowest swing low. Inverted: the mirror.
    A triangle's or wedge's lines go through its two highs and its two lows. They must meet after
    its last swing, and its height is the gap between them at its first swing, where it is widest.
    A flag's 4 swings are not also counted as a triangle or wedge.
    A pattern is checked when its last swing is known. It stays live until the next swing point is
    known. In between, the first candle that closes beyond the breakout line is the breakout: trade
    at the next candle's open. A pattern is dropped if a candle closed beyond its breakout line
    before that (from the line's first swing on), if a candle closes beyond its other side first
    (the stop-loss level after the last swing, or a triangle's or wedge's other line), or if a
    triangle's or wedge's lines meet first.
    Exit: the stop-loss goes at the last swing point on the other side of the pattern (the second
    top, the right shoulder, the handle's low, the flag's high...). The take-profit is the measured
    move: the pattern's height added to the breakout line's price on the breakout candle. Size
    every trade to lose 1% of the account at the stop-loss. One trade at a time; patterns that break
    out during a trade are skipped.
    One shape counts as one pattern: on each new swing point the patterns are checked in the order
    head and shoulders, cup and handle, flag, triangles (ascending and descending, then
    symmetrical), wedges, double top and bottom, and a pattern is skipped if one found before it
    already trades the same way. (A shape can be a double top and a bull flag at once: they trade in
    opposite directions, so both stay.) Two breakouts the opposite way on one candle: no trade.
    Skipped candles: a candle that opens on a Friday at 17:00 New York time or later (a few minutes
    of index prices after the weekly close make a tiny extra candle in some years), and a candle
    whose high equals its low (a market holiday in the price data). The strategy ignores them: they
    are never swing points or breakout candles. On a market that trades at the weekend, remove the
    Friday skip.
    pattern = 0 trades all 7 together; 1..7 trades one of them (numbers above).
    Changes, one at a time (off by default):
      two_closes = 1   wait for a second candle to close beyond the breakout line, and trade at the
                       open after it. If the second candle closes back inside, no trade.
      retest     = 1   after the breakout close, wait for price to come back to the breakout line:
                       a limit order at the line's price on the breakout candle. It waits up to
                       retest_bars candles, and is cancelled if price reaches the take-profit first.
    """
    params = {"pattern": Param(type=int, default=0, min=0, max=7),
              "swing_bars": Param(type=int, default=3, min=1, max=20),
              "tolerance": Param(type=float, default=0.15, min=0.0, max=1.0),
              "two_closes": Param(type=int, default=0, min=0, max=1),
              "retest": Param(type=int, default=0, min=0, max=1),
              "retest_bars": Param(type=int, default=10, min=1, max=100),
              "max_width": Param(type=int, default=60, min=10, max=500)}
    lookback = 2
    # name: (tag of the bearish form, tag of the bullish form, pattern number)
    NAMES = {"hs": ("head_shoulders", "inverse_head_shoulders", 2),
             "cup": ("inverted_cup_handle", "cup_handle", 7),
             "flag": ("bear_flag", "bull_flag", 5),
             "triangle": ("descending_triangle", "ascending_triangle", 3),
             "symmetrical": ("symmetrical_triangle_down", "symmetrical_triangle_up", 4),
             "wedge": ("rising_wedge", "falling_wedge", 6),
             "double": ("double_top", "double_bottom", 1)}
    ORDER = ("hs", "cup", "flag", "triangle", "symmetrical", "wedge", "double")
    def init(self, ctx):
        self.ny = ctx.clock("America/New_York")
        self.k = -1                 # number of the newest candle the strategy uses
        self.hi = []                # highs, lows and closes of those candles
        self.lo = []
        self.cl = []
        self.swings = []            # [kind, price, k]: kind 1 = swing high, -1 = swing low
        self.setups = []            # live patterns waiting for their breakout
        self.group = 0
        self.waiting = None         # two_closes: a breakout waiting for its second close
        self.order = None           # retest: the resting limit order
        self.order_k = None
        self.order_side = None
        self.order_target = None
        self.max_width = ctx.params.max_width
    # ---- candles, swings and breakouts (no orders here) ----------------------------------------
    def step(self, high, low, close, tol=0.15, n=3):
        """Add one candle. Returns the breakouts on its close: [(side, stop, target, level, tag, line)]."""
        self.k += 1
        k = self.k
        self.hi.append(high)
        self.lo.append(low)
        self.cl.append(close)
        out = []
        done = set()
        for su in self.setups:  # breakouts first: a symmetrical triangle's two sides share a group
            if su["group"] in done or (su["apex"] is not None and k >= su["apex"]):
                continue
            level = self.line_at(su["line"], k)
            if (su["side"] == 1 and close > level) or (su["side"] == -1 and close < level):
                out.append((su["side"], su["stop"], level + su["side"] * su["height"], level, su["tag"],
                            su["line"]))
                done.add(su["group"])
        live = [su for su in self.setups if su["group"] not in done
                and not (su["apex"] is not None and k >= su["apex"])
                and not self.beyond_other(su, k, close)]
        self.setups = live
        c = k - n
        if c - n >= 0:
            win = range(c - n, k + 1)
            top = all(self.hi[c] > self.hi[j] for j in win if j != c)
            bottom = all(self.lo[c] < self.lo[j] for j in win if j != c)
            changed = False
            if top and bottom:  # an outside candle: keep the side that takes turns with the last swing
                last = self.swings[-1][0] if self.swings else -1
                changed = self.add_swing(-last, self.hi[c] if last == -1 else self.lo[c], c)
            elif top:
                changed = self.add_swing(1, self.hi[c], c)
            elif bottom:
                changed = self.add_swing(-1, self.lo[c], c)
            if changed:
                self.setups = self.find_patterns(k, tol)
        return out
    def add_swing(self, kind, price, k):
        s = self.swings
        if s and s[-1][0] == kind:
            if (kind == 1 and price > s[-1][1]) or (kind == -1 and price < s[-1][1]):
                s[-1] = [kind, price, k]
                return True
            return False
        s.append([kind, price, k])
        if len(s) > 40:
            del s[0]
        return True
    @staticmethod
    def line_at(line, k):
        k0, p0, slope = line
        return p0 + slope * (k - k0)
    def beyond_other(self, su, k, close):
        """True when a candle at k closed beyond the pattern's other side."""
        if su["other"] is not None:
            other = self.line_at(su["other"], k)
            return close > other if su["side"] == -1 else close < other
        if su["cancel_at_stop"]:
            return close > su["stop"] if su["side"] == -1 else close < su["stop"]
        return False
    # ---- patterns --------------------------------------------------------------------------
    def find_patterns(self, k, tol):
        """The patterns that end at the newest swing, in ORDER, at most one per direction."""
        found = []
        claimed = set()
        mirror = [[-t, -p, kk] for t, p, kk in self.swings]
        detect = {"hs": self.pat_hs, "cup": self.pat_cup, "flag": self.pat_flag,
                  "triangle": self.pat_triangle, "symmetrical": self.pat_symmetrical,
                  "wedge": self.pat_wedge, "double": self.pat_double}
        for name in self.ORDER:
            cands = []
            for mirrored in (False, True):
                su = detect[name](mirror if mirrored else self.swings, tol, -1 if mirrored else 1)
                if su is None:
                    continue
                if mirrored:
                    su = self.unmirror(su)
                su["tag"] = self.NAMES[name][1 if su["side"] == 1 else 0]
                su["number"] = self.NAMES[name][2]
                cands.append(su)
            if not cands:
                continue
            if name == "symmetrical":  # one pattern with two sides: both must be free and inside
                if claimed & {1, -1} or not all(self.still_inside(su, k) for su in cands):
                    continue
                self.group += 1
                for su in cands:
                    su["group"] = self.group
                    found.append(su)
                claimed |= {1, -1}
                continue
            for su in cands:
                if su["side"] in claimed or not self.still_inside(su, k):
                    continue
                self.group += 1
                su["group"] = self.group
                found.append(su)
                claimed.add(su["side"])
        return found
    @staticmethod
    def unmirror(su):
        out = dict(su)
        out["side"] = -su["side"]
        out["line"] = (su["line"][0], -su["line"][1], -su["line"][2])
        if su["other"] is not None:
            out["other"] = (su["other"][0], -su["other"][1], -su["other"][2])
        out["stop"] = -su["stop"]
        return out
    def still_inside(self, su, k):
        """No close beyond the breakout line from its first swing on, and none beyond the other side
        (a triangle's or wedge's other line: from its first swing on; otherwise the stop-loss level,
        after the last swing). The lines of a triangle or wedge must not have met."""
        for j in range(su["line"][0], k + 1):
            level = self.line_at(su["line"], j)
            if (su["side"] == 1 and self.cl[j] > level) or (su["side"] == -1 and self.cl[j] < level):
                return False
        start = su["other"][0] if su["other"] is not None else su["last_k"] + 1
        for j in range(start, k + 1):
            if self.beyond_other(su, j, self.cl[j]):
                return False
        return su["apex"] is None or k < su["apex"]
    @staticmethod
    def setup(side, line, stop, height, last_k, other=None, apex=None, cancel_at_stop=True):
        return {"side": side, "line": line, "other": other, "stop": stop, "height": height,
                "last_k": last_k, "apex": apex, "cancel_at_stop": cancel_at_stop}
    # Each pat_ method reads the swings for the BEARISH form (find_patterns mirrors the prices for
    # the bullish form) and returns a sell setup, or None.
    def earlier_match(self, s, end, tol):
        """For the swing high s[end]: the most recent earlier swing high at about the same price with
        every swing high between them lower than both, at most max_width candles before it.
        Returns (index of that high, lowest swing low between them, its k) or None."""
        _, h2, k2 = s[end]
        inner = None            # highest swing high between the two
        low, k_low = None, None  # lowest swing low between the two
        for i in range(end - 1, -1, -1):
            t, p, kk = s[i]
            if k2 - kk > self.max_width:
                return None
            if t == -1:
                if low is None or p < low:
                    low, k_low = p, kk
                continue
            if inner is not None and inner >= h2:
                return None
            if low is not None and (inner is None or p > inner):
                height = max(p, h2) - low
                if height > 0 and abs(p - h2) <= tol * height:
                    return i, low, k_low
            inner = p if inner is None else max(inner, p)
        return None
    def pat_double(self, s, tol, sign):
        """Double top: the newest swing high and an earlier one at about the same price, every swing
        high between them lower than both. Sell below the lowest swing low between them."""
        if len(s) < 3 or s[-1][0] != 1:
            return None
        m = self.earlier_match(s, len(s) - 1, tol)
        if m is None:
            return None
        i, low, k_low = m
        h1, (_, h2, k2) = s[i][1], s[-1]
        return self.setup(-1, (k_low, low, 0.0), h2, max(h1, h2) - low, k2)
    def pat_hs(self, s, tol, sign):
        if len(s) < 5 or s[-1][0] != 1:
            return None
        (_, h1, k1), (_, l1, k2), (_, h2, k3), (_, l2, k4), (_, h3, k5) = s[-5:]
        if not (h2 > h1 and h2 > h3):
            return None
        neck = (k2, l1, (l2 - l1) / (k4 - k2))
        height = h2 - self.line_at(neck, k3)
        if height <= 0 or abs(h1 - h3) > tol * height:
            return None
        if h1 <= self.line_at(neck, k1) or h3 <= self.line_at(neck, k5):
            return None
        return self.setup(-1, neck, h3, height, k5)
    def pat_cup(self, s, tol, sign):
        """Inverted cup and handle: the newest swing is a high (the handle's top), the one before it a
        low (the right rim). The left rim is an earlier swing low at about the same price, with every
        swing low between them higher than both (the mirror of a double top's two tops). The cup is
        rounded: more than half of the candles between the rims close in its half nearest its
        extreme. The handle goes back at most half the cup's depth. Sell below the right rim."""
        if len(s) < 4 or s[-1][0] != 1 or s[-2][0] != -1:
            return None
        flip = [[-t, -p, kk] for t, p, kk in s[:-1]]  # rims as highs: reuse the double-top search
        m = self.earlier_match(flip, len(flip) - 1, tol)
        if m is None:
            return None
        i, top, _ = m
        top = -top                       # the cup's extreme (its highest swing high here)
        ka, (_, c, kc), (_, d, kd) = s[i][2], s[-2], s[-1]
        depth = top - c
        if depth <= 0 or d - c > 0.5 * depth:
            return None  # the handle goes back more than half the cup's depth
        mid = (top + c) / 2
        inside = range(ka + 1, kc)
        near = sum(1 for j in inside if sign * self.cl[j] > mid)
        if not near * 2 > len(inside):
            return None  # not rounded: price did not spend most of the cup near its extreme
        return self.setup(-1, (kc, c, 0.0), d, depth, kd)
    def pat_flag(self, s, tol, sign=1):
        """Bear flag: high (the pole's start), low (its end), a bounce of at most half the pole,
        then a higher low."""
        if len(s) < 4 or s[-1][0] != -1:
            return None
        (_, h0, _), (_, l0, k1), (_, h1, _), (_, l1, k3) = s[-4:]
        pole = h0 - l0
        if pole <= 0 or h1 - l0 > 0.5 * pole or not l1 > l0:
            return None
        return self.setup(-1, (k1, l0, (l1 - l0) / (k3 - k1)), h1, pole, k3)
    def four(self, s, tol):
        """The last 4 swings as two lines: (upper, lower, height at the first swing, highs' move,
        lows' move, apex, last high, last low), moves 1 rising, -1 falling, 0 flat. None unless
        the lines meet after the last swing, or if the 4 swings are a flag."""
        if len(s) < 4:
            return None
        sw = s[-4:]
        mir = [[-t, -p, kk] for t, p, kk in sw]
        if any(self.pat_flag(x, tol) is not None for x in (sw, mir)):
            return None  # a flag is not counted as a triangle or wedge
        (ka, ha), (kb, hb) = [(kk, p) for t, p, kk in sw if t == 1]
        (kc, la), (kd, lb) = [(kk, p) for t, p, kk in sw if t == -1]
        up = (ka, ha, (hb - ha) / (kb - ka))
        low = (kc, la, (lb - la) / (kd - kc))
        k_first = sw[0][2]
        height = self.line_at(up, k_first) - self.line_at(low, k_first)
        if height <= 0 or not up[2] < low[2]:
            return None
        apex = k_first + height / (low[2] - up[2])
        if apex <= sw[-1][2]:
            return None
        lim = tol * height
        hm = 1 if hb - ha > lim else -1 if ha - hb > lim else 0
        lm = 1 if lb - la > lim else -1 if la - lb > lim else 0
        return up, low, height, hm, lm, apex, hb, lb
    def pat_triangle(self, s, tol, sign):
        """Descending triangle: falling highs, flat lows. Sell below the lower line."""
        f = self.four(s, tol)
        if f is None or not (f[3] == -1 and f[4] == 0):
            return None
        up, low, height, _, _, apex, hb, _ = f
        return self.setup(-1, low, hb, height, s[-1][2], other=up, apex=apex, cancel_at_stop=False)
    def pat_symmetrical(self, s, tol, sign):
        """Symmetrical triangle, its sell side: falling highs, rising lows. Sell below the lower line
        (find_patterns adds the buy side above the upper line from the mirror image)."""
        f = self.four(s, tol)
        if f is None or not (f[3] == -1 and f[4] == 1):
            return None
        up, low, height, _, _, apex, hb, _ = f
        return self.setup(-1, low, hb, height, s[-1][2], other=up, apex=apex, cancel_at_stop=False)
    def pat_wedge(self, s, tol, sign):
        """Rising wedge: rising highs and rising lows, the lines meeting ahead. Sell below the lower
        line."""
        f = self.four(s, tol)
        if f is None or not (f[3] == 1 and f[4] == 1):
            return None
        up, low, height, _, _, apex, hb, _ = f
        return self.setup(-1, low, hb, height, s[-1][2], other=up, apex=apex, cancel_at_stop=False)
    # ---- trading ---------------------------------------------------------------------------
    def on_bar(self, ctx):
        # A tiny candle after the Friday close, or a candle with no price movement: ignore it.
        if self.ny.weekday == 4 and self.ny.hour >= 17:
            return
        high, low, close = ctx.high[0], ctx.low[0], ctx.close[0]
        if not high > low:
            return
        p = ctx.params
        breakouts = self.step(high, low, close, p.tolerance, p.swing_bars)
        if p.pattern != 0:
            breakouts = [b for b in breakouts if self.number_of(b[4]) == p.pattern]
        if self.order is not None:  # retest: a limit order is waiting
            if self.order.state.value != "pending" or ctx.position is not None:
                self.order = None
            else:
                reached = high >= self.order_target if self.order_side == 1 else low <= self.order_target
                if reached or self.k - self.order_k >= p.retest_bars:
                    ctx.cancel_order(self.order.order_id)
                    self.order = None
                return
        if ctx.position is not None:
            self.waiting = None
            return
        waiting, self.waiting = self.waiting, None
        if waiting is not None:  # two_closes: the candle after the first close beyond the line
            side, stop, target, level, tag, line = waiting
            now = self.line_at(line, self.k)
            if ctx.gate("second_close_beyond_line", close > now if side == 1 else close < now):
                self.enter(ctx, side, stop, target, level, tag)
            return
        if not ctx.gate("pattern_breakout", len(breakouts) > 0):
            return
        if not ctx.gate("one_direction", all(b[0] == breakouts[0][0] for b in breakouts)):
            return
        if p.two_closes == 1:
            self.waiting = breakouts[0]
            return
        side, stop, target, level, tag, _ = breakouts[0]
        self.enter(ctx, side, stop, target, level, tag)
    def number_of(self, tag):
        for bear, bull, number in self.NAMES.values():
            if tag in (bear, bull):
                return number
        return None
    def enter(self, ctx, side, stop, target, level, tag):
        entry = level if ctx.params.retest == 1 else ctx.close[0]
        # The stop-loss must be behind the entry and the take-profit ahead of it.
        ok = stop < entry < target if side == 1 else target < entry < stop
        if not ctx.gate("room_to_target", ok):
            return
        size = ctx.size_by_risk_pct(0.01, stop=stop, entry=entry)
        if ctx.params.retest == 1:
            if side == 1:
                self.order = ctx.buy(size=size, limit=entry, sl=stop, tp=target, tag=tag)
            else:
                self.order = ctx.sell(size=size, limit=entry, sl=stop, tp=target, tag=tag)
            if self.order is not None:
                self.order_k, self.order_side, self.order_target = self.k, side, target
            return
        if side == 1:
            ctx.buy(size=size, sl=stop, tp=target, tag=tag)
        else:
            ctx.sell(size=size, sl=stop, tp=target, tag=tag)