Multi-Timeframe Confluence Reduces False Signals

[FTtrader]

How to use this in TradingView:

1.) Open a 5-Minute Chart (The script assumes the chart it is applied to is your Lower Timeframe).

2.) Open the Pine Editor tab at the bottom of the screen.

3.) Paste the code, click Save, and then click Add to Chart.

4.) The strategy will automatically fetch the 4-Hour and 15-Minute data in the background, plotting a faint green or red background color whenever all three timeframes perfectly align.

[FTtrader]

To make this script truly "professional grade" in Pine Script, we need to upgrade it from a simple signal generator into a complete, robust algorithmic trading system.

1.) Here are the professional features I have added to this version:

2.) Dynamic Risk Management: Instead of buying a flat percentage of equity, it now calculates precise position sizing based on risking a fixed percentage of your account (e.g., 1%) per trade.

3.) ATR-Based Stops & Targets: It dynamically calculates your Stop Loss and Take Profit based on market volatility (Average True Range) and a Risk-to-Reward ratio, rather than holding trades indefinitely.

4.) Live Dashboard: A dynamic UI table in the corner of the chart that shows you exactly what each of the three timeframes is currently doing in real-time.

5.) Time Window Filtering: Backtesting inputs that allow you to constrain the strategy to specific dates so you can measure forward-testing vs. historical performance.

6.) State Management: It ensures it only takes one trade at a time and manages the exit properly.

The "Pro" Pine Script (v5)

Code: Select all

//@version=5
strategy("Triple Timeframe Pro [Algo]", overlay=true, initial_capital=10000, default_qty_type=strategy.cash, commission_value=0.03, margin_long=100, margin_short=100)

// =========================================================================
// 1. INPUTS & PARAMETERS
// =========================================================================
grp_tf = "--- Timeframe Setup ---"
htf = input.timeframe("240", "Higher Timeframe (Bias)", group=grp_tf)
mtf = input.timeframe("15",  "Medium Timeframe (Setup)", group=grp_tf)

grp_strat = "--- Technical Parameters ---"
ma_fast_len = input.int(50,  "HTF Fast EMA", group=grp_strat)
ma_slow_len = input.int(200, "HTF Slow EMA", group=grp_strat)
rsi_len     = input.int(14,  "MTF RSI Length", group=grp_strat)
rsi_ob      = input.float(70, "MTF Overbought Level", group=grp_strat)
rsi_os      = input.float(30, "MTF Oversold Level", group=grp_strat)
ltf_ema_len = input.int(10,  "LTF Trigger EMA", group=grp_strat)

grp_risk = "--- Risk & Trade Management ---"
risk_perc = input.float(1.0, "Risk Per Trade (%)", step=0.1, group=grp_risk)
atr_len   = input.int(14, "ATR Length (For Stop Loss)", group=grp_risk)
sl_mult   = input.float(1.5, "Stop Loss (ATR Multiplier)", step=0.1, group=grp_risk)
rr_ratio  = input.float(2.0, "Take Profit (Risk:Reward Ratio)", step=0.1, group=grp_risk)

grp_time = "--- Backtest Window ---"
start_date = input.time(timestamp("2024-01-01 00:00"), "Start Date", group=grp_time)
end_date   = input.time(timestamp("2030-01-01 00:00"), "End Date", group=grp_time)
in_window  = true

// =========================================================================
// 2. NON-REPAINTING SECURITY FUNCTION
// =========================================================================
// Pulls the last closed bar of the higher timeframe to prevent backtest bias
f_secure_htf(_tf, _src) =>
    request.security(syminfo.tickerid, _tf, _src[1], lookahead = barmerge.lookahead_on)

// =========================================================================
// 3. TIMEFRAME CALCULATIONS
// =========================================================================
// -- HTF Bias --
htf_fast_ema = f_secure_htf(htf, ta.ema(close, ma_fast_len))
htf_slow_ema = f_secure_htf(htf, ta.ema(close, ma_slow_len))
htf_bullish  = (htf_fast_ema > htf_slow_ema)
htf_bearish  = (htf_fast_ema < htf_slow_ema)

// -- MTF Setup Zone --
mtf_rsi        = f_secure_htf(mtf, ta.rsi(close, rsi_len))
mtf_oversold   = (mtf_rsi < rsi_os)
mtf_overbought = (mtf_rsi > rsi_ob)

// -- LTF Trigger --
ltf_ema          = ta.ema(close, ltf_ema_len)
ltf_buy_trigger  = (open < ltf_ema and close > ltf_ema)
ltf_sell_trigger = (open > ltf_ema and close < ltf_ema)

// =========================================================================
// 4. RISK MANAGEMENT & SIZING
// =========================================================================
ltf_atr = ta.atr(atr_len)
sl_dist = ltf_atr * sl_mult
tp_dist = sl_dist * rr_ratio

// Calculate how many units we can buy without risking more than X% of account
risk_in_dollars = (strategy.equity * (risk_perc / 100))
pos_size        = risk_in_dollars / sl_dist

// =========================================================================
// 5. EXECUTION LOGIC
// =========================================================================
// Only trigger if we are flat (not already in a position)
is_flat = strategy.position_size == 0

long_cond  = htf_bullish and mtf_oversold and ltf_buy_trigger and in_window and is_flat
short_cond = htf_bearish and mtf_overbought and ltf_sell_trigger and in_window and is_flat

// Entry & Automated Bracket Orders (SL/TP)
if (long_cond)
    strategy.entry("Long", strategy.long, qty=pos_size)
    strategy.exit("Exit Long", "Long", stop=close - sl_dist, limit=close + tp_dist)

if (short_cond)
    strategy.entry("Short", strategy.short, qty=pos_size)
    strategy.exit("Exit Short", "Short", stop=close + sl_dist, limit=close - tp_dist)

// =========================================================================
// 6. VISUALIZATION & UI DASHBOARD
// =========================================================================
// Plot LTF Trigger EMA
plot(ltf_ema, color=color.new(color.yellow, 0), title="LTF Trigger EMA")

// Draw visual markers on the chart where trades are taken
plotshape(long_cond,  title="Buy Signal",  style=shape.triangleup,   location=location.belowbar, color=color.green, size=size.small)
plotshape(short_cond, title="Sell Signal", style=shape.triangledown, location=location.abovebar, color=color.red,   size=size.small)

// UI Dashboard configuration
var table dash = table.new(position.top_right, 2, 4, border_width=1, border_color=color.new(color.gray, 50))

if barstate.islast
    // Headers
    table.cell(dash, 0, 0, "Timeframe", text_color=color.white, bgcolor=color.new(color.black, 20))
    table.cell(dash, 1, 0, "Current Status", text_color=color.white, bgcolor=color.new(color.black, 20))
    
    // HTF Row
    table.cell(dash, 0, 1, "HTF Bias", text_color=color.white, bgcolor=color.new(color.black, 50))
    table.cell(dash, 1, 1, htf_bullish ? "BULLISH" : (htf_bearish ? "BEARISH" : "FLAT"), text_color=color.white, bgcolor=htf_bullish ? color.new(color.teal, 30) : (htf_bearish ? color.new(color.maroon, 30) : color.new(color.gray, 50)))
    
    // MTF Row
    table.cell(dash, 0, 2, "MTF Zone", text_color=color.white, bgcolor=color.new(color.black, 50))
    table.cell(dash, 1, 2, mtf_oversold ? "OVERSOLD" : (mtf_overbought ? "OVERBOUGHT" : "WAITING"), text_color=color.white, bgcolor=mtf_oversold ? color.new(color.teal, 30) : (mtf_overbought ? color.new(color.maroon, 30) : color.new(color.gray, 50)))
    
    // LTF Row
    table.cell(dash, 0, 3, "LTF Trigger", text_color=color.white, bgcolor=color.new(color.black, 50))
    table.cell(dash, 1, 3, ltf_buy_trigger ? "BUY FIRED" : (ltf_sell_trigger ? "SELL FIRED" : "WAITING"), text_color=color.white, bgcolor=ltf_buy_trigger ? color.new(color.teal, 30) : (ltf_sell_trigger ? color.new(color.maroon, 30) : color.new(color.gray, 50)))

[FTtrader]

Pro Features Explained:

The Dashboard (Top Right): Once you apply this to the chart, you will see a small table in the corner. You no longer have to manually check the 4-hour or 15-minute charts. The dashboard will display real-time background color changes (Teal for Bullish/Oversold, Maroon for Bearish/Overbought). When everything is Teal, the system strikes.

strategy.exit Bracket Orders: Instead of just sending a raw entry, this uses advanced bracket logic. The moment the entry is triggered, the script automatically mounts a Stop Loss and Take Profit to the order using the sl_mult and rr_ratio parameters.

Volatility Adjustment: A 10-pip stop loss makes no sense if the market is barely moving, but it's dangerously tight if the market is highly volatile. By basing the Stop Loss on the ATR (Average True Range), the system dynamically gives the trade more room to breathe during volatile sessions, and tighter stops during quiet sessions.

[FTtrader]

And do not worry, i prepared that for Ctrader/Ictrader traders as well in pro version:

Here is the professional-grade implementation for cTrader (using C# and the cTrader Automate API).

Translating this to cTrader is actually where this strategy thrives. The cTrader API (cAlgo) is fundamentally built for multi-timeframe analysis. Instead of constantly shifting index buffers like in MT4, cTrader allows us to instantiate completely independent series of Bars and pass them directly into our indicators.

I’ve included all the "Pro" features from the Pine Script version: automated ATR-based position sizing, bracket orders (Stop Loss & Take Profit), and an on-chart text dashboard.

The cTrader cBot (C#)

Code: Select all

using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class TripleTimeframePro : Robot
    {
        // =========================================================================
        // 1. TIMEFRAME INPUTS
        // =========================================================================
        [Parameter("Higher Timeframe (Bias)", Group = "Timeframes", DefaultValue = "Hour4")]
        public TimeFrame Htf { get; set; }

        [Parameter("Medium Timeframe (Setup)", Group = "Timeframes", DefaultValue = "Minute15")]
        public TimeFrame Mtf { get; set; }

        // Note: The chart timeframe where you attach the cBot acts as the Lower Timeframe (LTF)

        // =========================================================================
        // 2. STRATEGY INPUTS
        // =========================================================================
        [Parameter("HTF Fast EMA", Group = "Technical Parameters", DefaultValue = 50)]
        public int MaFastLen { get; set; }

        [Parameter("HTF Slow EMA", Group = "Technical Parameters", DefaultValue = 200)]
        public int MaSlowLen { get; set; }

        [Parameter("MTF RSI Length", Group = "Technical Parameters", DefaultValue = 14)]
        public int RsiLen { get; set; }

        [Parameter("LTF Trigger EMA", Group = "Technical Parameters", DefaultValue = 10)]
        public int LtfEmaLen { get; set; }

        // =========================================================================
        // 3. RISK MANAGEMENT INPUTS
        // =========================================================================
        [Parameter("Risk Per Trade (%)", Group = "Risk & Position Sizing", DefaultValue = 1.0, MinValue = 0.1, Step = 0.1)]
        public double RiskPercentage { get; set; }

        [Parameter("ATR Length", Group = "Risk & Position Sizing", DefaultValue = 14)]
        public int AtrLength { get; set; }

        [Parameter("SL (ATR Multiplier)", Group = "Risk & Position Sizing", DefaultValue = 1.5, MinValue = 0.1, Step = 0.1)]
        public double SlMultiplier { get; set; }

        [Parameter("TP (Risk:Reward Ratio)", Group = "Risk & Position Sizing", DefaultValue = 2.0, MinValue = 0.1, Step = 0.1)]
        public double RrRatio { get; set; }

        // --- Global Variables & Indicators ---
        private Bars _htfBars;
        private Bars _mtfBars;

        private ExponentialMovingAverage _htfFastEma;
        private ExponentialMovingAverage _htfSlowEma;
        private RelativeStrengthIndex _mtfRsi;
        private ExponentialMovingAverage _ltfEma;
        private AverageTrueRange _ltfAtr;

        private const string BotLabel = "TripleTF_Pro";

        protected override void OnStart()
        {
            // 1. Request Market Data for the other timeframes
            _htfBars = MarketData.GetBars(Htf);
            _mtfBars = MarketData.GetBars(Mtf);

            // 2. Initialize Indicators, attaching them to their respective timeframe data
            _htfFastEma = Indicators.ExponentialMovingAverage(_htfBars.ClosePrices, MaFastLen);
            _htfSlowEma = Indicators.ExponentialMovingAverage(_htfBars.ClosePrices, MaSlowLen);
            _mtfRsi = Indicators.RelativeStrengthIndex(_mtfBars.ClosePrices, RsiLen);
            
            // LTF (Current Chart) Indicators
            _ltfEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, LtfEmaLen);
            _ltfAtr = Indicators.AverageTrueRange(Bars, AtrLength, MovingAverageType.Simple);
        }

        protected override void OnBar()
        {
            // OnBar() triggers exactly when a new LTF candle opens. 
            // By looking at index Last(1), we evaluate the bar that JUST closed.

            // =========================================================
            // 1. HIGHER TIMEFRAME (Directional Bias)
            // =========================================================
            // Last(1) pulls the most recently closed HTF bar, preventing repainting
            double htfFast = _htfFastEma.Result.Last(1);
            double htfSlow = _htfSlowEma.Result.Last(1);

            bool isHtfBullish = htfFast > htfSlow;
            bool isHtfBearish = htfFast < htfSlow;

            // =========================================================
            // 2. MEDIUM TIMEFRAME (Setup Zone)
            // =========================================================
            double mtfRsiValue = _mtfRsi.Result.Last(1);

            bool isMtfOversold = mtfRsiValue < 30.0;
            bool isMtfOverbought = mtfRsiValue > 70.0;

            // =========================================================
            // 3. LOWER TIMEFRAME (Entry Trigger)
            // =========================================================
            double ltfEmaValue = _ltfEma.Result.Last(1);
            double ltfClose = Bars.ClosePrices.Last(1);
            double ltfOpen = Bars.OpenPrices.Last(1);

            bool isLtfBuyTrigger = ltfOpen < ltfEmaValue && ltfClose > ltfEmaValue;
            bool isLtfSellTrigger = ltfOpen > ltfEmaValue && ltfClose < ltfEmaValue;

            // Update UI Dashboard
            UpdateDashboard(isHtfBullish, isHtfBearish, isMtfOversold, isMtfOverbought, isLtfBuyTrigger, isLtfSellTrigger);

            // =========================================================
            // 4. EXECUTION
            // =========================================================
            // Do not open a new position if one is already running
            if (Positions.FindAll(BotLabel, SymbolName).Length > 0) return;

            if (isHtfBullish && isMtfOversold && isLtfBuyTrigger)
            {
                ExecuteTrade(TradeType.Buy);
            }
            else if (isHtfBearish && isMtfOverbought && isLtfSellTrigger)
            {
                ExecuteTrade(TradeType.Sell);
            }
        }

        private void ExecuteTrade(TradeType tradeType)
        {
            // 1. Calculate SL and TP dynamically based on volatility
            double atr = _ltfAtr.Result.Last(1);
            double stopLossDistance = atr * SlMultiplier;
            double takeProfitDistance = stopLossDistance * RrRatio;

            // Convert distances to Pips for cTrader execution
            double slPips = Math.Round(stopLossDistance / Symbol.PipSize, 1);
            double tpPips = Math.Round(takeProfitDistance / Symbol.PipSize, 1);

            // 2. Dynamic Position Sizing (Risk %)
            double riskAmount = Account.Equity * (RiskPercentage / 100.0);
            
            // Calculate how much volume we can buy based on our risk amount and SL distance
            double volumeCalc = riskAmount / (slPips * Symbol.PipValue);
            
            // Normalize volume to broker's allowed steps (e.g., 1,000 units = 0.01 lots)
            double finalVolume = Symbol.NormalizeVolumeInUnits(volumeCalc, RoundingMode.Down);

            if (finalVolume < Symbol.VolumeInUnitsMin)
            {
                Print("Calculated volume is below broker minimum. Trade aborted.");
                return;
            }

            // 3. Execute Order
            ExecuteMarketOrder(tradeType, SymbolName, finalVolume, BotLabel, slPips, tpPips);
            Print($"Triple Alignment Setup Executed: {tradeType} | Vol: {finalVolume} | SL: {slPips} pips");
        }

        private void UpdateDashboard(bool htfBull, bool htfBear, bool mtfOs, bool mtfOb, bool ltfBuy, bool ltfSell)
        {
            string htfStatus = htfBull ? "BULLISH" : (htfBear ? "BEARISH" : "FLAT");
            string mtfStatus = mtfOs ? "OVERSOLD" : (mtfOb ? "OVERBOUGHT" : "WAITING");
            string ltfStatus = ltfBuy ? "BUY FIRED" : (ltfSell ? "SELL FIRED" : "WAITING");

            string dashText = $"--- Triple Timeframe Algo ---\n\n" +
                              $"HTF Bias:  {htfStatus}\n" +
                              $"MTF Zone:  {mtfStatus}\n" +
                              $"LTF Trig:  {ltfStatus}\n\n" +
                              $"Equity Risk: {RiskPercentage}%";

            Chart.DrawText("Dashboard", dashText, VerticalAlignment.Top, HorizontalAlignment.Right, Color.White);
        }
    }
}

[FTtrader]

Pro Features Explained (cTrader Edition)

MarketData.GetBars(TimeFrame): Instead of calling standard moving averages and forcing a timeframe inside the indicator setup, cTrader lets you instantiate the physical chart data of the 4H and 15m charts via GetBars(), and then apply indicators directly to those objects in OnStart(). This runs infinitely faster in backtesting than MT4.

Repaint Proofing (.Last(1)): Using OnBar() means the code fires at the absolute open of a new 5-minute candle. Because we check Last(1) across all three timeframes, we are looking only at fully formed, closed data. It is mechanically impossible for this cBot to repaint its past signals.

cTrader Dynamic Sizing: Instead of using fixed lots, it calculates Account.Equity * Risk%, divides it by the Stop Loss distance in pips, and scales it securely against Symbol.PipValue. Finally, Symbol.NormalizeVolumeInUnits() rounds it strictly to the step-sizes permitted by your specific broker (e.g., standardizing 12,345 units down to 12,000 units).

How to use this:

1.) Open cTrader and switch to the Automate tab on the left.

2.) Click New cBot and name it "TripleTimeframePro".

3.) Erase the default code, paste this in, and click the Build (Hammer) icon at the top.

4.) Attach it to a 5-Minute chart, configure your Risk % and ATR multipliers in the parameters window, and click Start. The dashboard will automatically appear in the top right corner.

[Fairman]

Using a single timeframe in isolation means you're making decisions with a genuinely incomplete picture of what's happening in the market. A more robust approach uses three timeframes together, each serving a distinct, specific purpose in your decision-making process.

Start with the higher timeframe — the 1-hour or 4-hour chart — to establish your overall directional bias. Is the broader market trending, ranging, near a major support or resistance zone? This sets the context for everything else.

Move to a medium timeframe — commonly the 15-minute chart — to identify the specific zone or level where you're actually looking for an opportunity within that broader context. This is where you narrow down from "the market is generally bullish" to "the market is bullish and approaching this specific support zone."

Finally, drop down to your lower timeframe — the 1-minute or 5-minute chart — purely for entry timing. This is where you look for the precise trigger — the rejection candle, the break of a minor structure point, the momentum confirmation — that tells you now is the moment to actually enter, rather than simply hovering near the zone identified on the medium timeframe.

Trading only when all three timeframes are in genuine agreement filters out a substantial share of the lower-probability setups that a single-timeframe approach would have taken. Yes, this means fewer total trades. That's the point — quality over quantity, consistently.

Hello Fairman,

Spot on. Trying to trade off a single timeframe is like trying to drive a car while looking through a paper towel tube—you might see exactly what’s right in front of you, but you have no idea if you're driving straight into a brick wall.

The three-timeframe approach you described perfectly separates bias, setup, and execution. The biggest mistake newer traders make when jumping into multi-timeframe analysis is expecting all three charts to look exactly the same. If the H4 is bullish, the M15 doesn't always have to be screaming "up"—in fact, a bearish M15 pullback into a support zone is exactly what gives you the discount you need before the M5 trigger finally gets you in.

Accepting that this triple-filter method cuts out 70% of potential trades is a feature, not a bug. Quality over quantity is the only way to survive the variance in this game. Great post.

Exactly, that’s as simple as it gets