Turtle Soup Strategy

Turtle Soup is a short-term reversal idea that fades false breakouts of a recent high or low. The name comes from a setup popularized by Linda Raschke and Larry Connors in "Street Smarts" as a counter-trade to breakout-style trend systems like the well-known "Turtle" approach: when price pokes just beyond a prior N-bar extreme and then snaps back inside the range, traders read it as a failed breakout rather than a real one. This page explains how the pattern is defined and interpreted for study. It is educational/software content only and makes no claim about profitability or future results.

How it works

The setup watches a lookback window — classically the prior 20 bars — to find the lowest low or highest high. A potential setup forms when the current bar trades through that level (a new N-bar low or high), suggesting a breakout. The "soup" is the reversal: instead of continuing, price closes back inside the prior range, which traders interpret as a breakout that failed and trapped participants who chased it. A long candidate looks for a marginal new low that is reclaimed; a short candidate looks for a marginal new high that fails. Many traders also require the broken level to have been set at least a few bars earlier (so it is a "fresh" extreme), then act on the snap-back, placing a protective stop just beyond the false-breakout extreme. The logic is about liquidity and trapped orders, not prediction — there is no guarantee any given failed breakout reverses, and many do not. Want this checked for look-ahead bias and repainting? Run it through the ForexCodes Strategy Validator or try it free.

Entry rules

Define a lookback window for the prior extreme (commonly 20 bars), excluding the current bar.
Long candidate: price trades below the prior N-bar low (a marginal new low), ideally where that prior low was set several bars ago.
Long trigger: price reclaims the broken level and closes back above the prior N-bar low, which traders read as a failed downside breakout.
Short candidate: price trades above the prior N-bar high (a marginal new high).
Short trigger: price fails and closes back below the prior N-bar high, which traders read as a failed upside breakout.
Some traders add a confirmation filter (e.g., a close back inside the range, or a same-session reversal) to reduce reaction to every minor poke.
Treat these as conditions for study and discretionary review, not mechanical buy/sell instructions.

Exit rules

Protective stop just beyond the false-breakout extreme (below the marginal new low for longs, above the marginal new high for shorts), so an actual breakout invalidates the idea.
Some traders use the opposite side of the recent range or a prior swing level as a reference target, but levels are arbitrary and are chosen by the trader, not fixed by the pattern.
Time-based exit: many short-term traders close the position if the expected snap-back has not developed within a set number of bars.
Trailing the stop or scaling out as price moves back into the range is a discretionary choice; it changes the risk profile and does not guarantee any particular outcome.
Exits, like entries, carry risk; a stop does not guarantee the fill price, especially around gaps or fast markets.

Risk notes

This is educational/software content, not trading advice or a recommendation to buy or sell.
Nothing here is predictive; failed-breakout patterns do not forecast future price, and trading involves the risk of loss.
Backtests and the example code are illustrative only — past performance does not indicate future results, and live conditions (slippage, spreads, gaps) differ.
Stops do not guarantee exit price; markets can gap through protective levels.
"Turtle" and any related system names referenced here belong to their respective owners; this page is independent and for study only.
Validate any version of this logic for look-ahead bias and repainting before relying on its signals.

Pine v6 example

//@version=6
strategy("Turtle Soup (illustrative)", overlay=true, calc_on_every_tick=false)

// Inputs
lookback  = input.int(20, "Lookback bars", minval=2)
freshBars = input.int(3,  "Min bars since extreme was set", minval=0)

// Prior N-bar extremes, excluding the current bar (no look-ahead)
priorLow  = ta.lowest(low[1],  lookback)
priorHigh = ta.highest(high[1], lookback)

// Rough freshness check: how long since the prior-bar extreme last matched
// the lookback extreme. This is an approximation, not an exact bar count.
barsSinceLow  = ta.barssince(low[1]  == priorLow)
barsSinceHigh = ta.barssince(high[1] == priorHigh)

// Long: marginal new low this bar, then close back above the prior low
longSetup  = low < priorLow and close > priorLow and barsSinceLow >= freshBars

// Short: marginal new high this bar, then close back below the prior high
shortSetup = high > priorHigh and close < priorHigh and barsSinceHigh >= freshBars

// Orders execute on the next bar's open; stop sits beyond the signal-bar extreme
if longSetup
    strategy.entry("TS Long", strategy.long)
    strategy.exit("TS Long Exit", from_entry="TS Long", stop=low, limit=priorHigh)

if shortSetup
    strategy.entry("TS Short", strategy.short)
    strategy.exit("TS Short Exit", from_entry="TS Short", stop=high, limit=priorLow)

plot(priorLow,  "Prior N-bar Low",  color=color.new(color.red, 0))
plot(priorHigh, "Prior N-bar High", color=color.new(color.green, 0))
// Educational example only. Backtests are illustrative; past performance does not predict future results.

Pitfalls

Repainting risk: referencing the current bar's extreme (e.g., ta.lowest(low, lookback) including bar 0) can make signals shift intrabar. Anchor the lookback to completed bars (low[1]/high[1]) as shown.
Look-ahead bias: never compare a signal to data that wasn't available when the bar formed. Using next-bar opens for execution and prior-bar levels for logic avoids this.
Defining the breakout level off the current bar means the 'new low' both sets and breaks the level on the same bar — separate the prior extreme from the current bar to keep the test honest.
Freshness check is approximate: ta.barssince(low[1] == priorLow) only flags exact matches of the prior-bar low to the running extreme, so it is a rough proxy, not a precise count of bars since the swing. Treat it as a coarse filter and validate it before relying on it.
Marginal-vs-deep breakouts: the classic idea is a small poke beyond the level; a large, decisive break is a different scenario and the snap-back assumption may not hold.
Over-trading: on noisy intraday data almost every bar pokes some recent extreme. Without a freshness or confirmation filter the setup fires constantly.
Curve-fitting the lookback, freshness, and target inputs to one chart can produce results that do not generalize.
No edge is guaranteed: failed breakouts can resume in the original breakout direction, turning the protective stop into a loss.

FAQ

Why is it called "Turtle Soup"?

It was framed as a counter-trade to trend-following breakout systems like the well-known "Turtle" approach, which buys new highs and sells new lows. Turtle Soup instead fades those same breakouts when they fail — hence "making soup" out of the turtles. It is simply a memorable name for a failed-breakout reversal pattern. "Turtle" and related names belong to their respective owners.

What lookback period should I use?

The original write-ups used a 20-bar window, but the number is a parameter, not a rule. Different markets and timeframes behave differently, and tuning the lookback to fit one chart risks curve-fitting. Test any setting on out-of-sample data and treat the choice as a study variable, not a guaranteed edge.

Does the Turtle Soup pattern work?

There is no reliable answer to "does it work" — no pattern is predictive, and failed breakouts can just as easily resume in the original breakout direction. Traders use it as a structured way to study liquidity and trapped-order behavior. Any historical results are illustrative only and do not indicate future performance; trading carries the risk of loss.

How do I make sure my version doesn't repaint?

Anchor the breakout level to completed bars (use low[1]/high[1] in the lookback rather than the live bar), confirm signals on bar close, and execute on the next bar's open. Running the script through the ForexCodes Strategy Validator flags look-ahead bias, repainting, and intent mismatches automatically.

Want this as a clean, validated Pine script? run it through the Validator → or convert a trading strategy to Pine Script →

Educational & software only — not financial advice, not a recommendation to trade. Backtests are illustrative; past performance does not predict future results. Trading involves substantial risk of loss.