Liquidity Trap Trading Strategy: Buy Below Lows, Sell Above Highs

Q: How many trades per week?

With 2-3 pairs (XAUUSD, EURUSD, US30) you will see 5-8 valid setups per week on average. Some weeks produce fewer.

Q: What if price runs away without sweeping my level?

The trade was never yours to take. The untouched level becomes a future target. Patience is the hardest and most profitable skill.

Q: Does this work on crypto?

The framework applies but crypto lacks centralized order books. Forex and futures are recommended for clean execution.

The institutional liquidity strategy that identifies where retail traders are trapped — and enters exactly where they are forced to exit. Complete framework with XAUUSD and EURUSD walkthroughs, quantifiable rules, and free MQL5 EA architecture.

July 20, 2026 | 22 min read

Why Most Traders Lose — and Where the Edge Actually Sits
Core Principle: Buy Below Lows, Sell Above Highs
What Is Liquidity — A Quant Definition
The 3-Step Directional Bias Framework
XAUUSD Detailed Walkthrough
EURUSD Detailed Walkthrough
Internal vs External Liquidity
Strict Rules That Keep You Safe
MQL5 EA Automation: Architecture & Code
Adapting the Strategy for Prop Firms
Frequently Asked Questions

1. Why Most Traders Lose — and Where the Edge Actually Sits

Retail traders lose for one structural reason: they enter at the same price levels where institutional liquidity is being engineered — not where it's being taken. Every support break, every trendline violation, every order block rejection that a retail trader sees as an opportunity is actually the mechanism that builds resting orders for the other side to consume.

The terms vary — stop-loss hunting, false breaks, shake-outs, inducement, manipulation — but the mechanism is identical. A level is shown to hold. Retail commits. The level breaks. Retail stops are taken. The real move begins. The trader who entered on the break is now trapped on the wrong side, and their stop-loss becomes fuel for the next leg.

Smart money concepts (SMC), ICT, supply and demand, Fibonacci — these frameworks do work temporarily. They have to. If they never worked, nobody would trade them, and no liquidity would accumulate at those levels. But they work just often enough to induce participation, and just unreliably enough to destroy the trader who hasn't identified where the trap sits.

Retail Trader Mindset		Liquidity Trader Mindset
Sees support holding — enters long	→	Sees support broken — enters long below it
Sees resistance holding — enters short	→	Sees resistance broken — enters short above it
Chases momentum after breakout	→	Waits for return to the break level, then enters opposite
Stop-loss is a risk management tool	→	Retail stop-losses are the fuel that drives price to target
Fears fake-outs and false breaks	→	The false break is the entry signal
Partial at 1:3 RR regardless of structure	→	Targets only opposing liquidity pools — no random exit points

2. Core Principle: Buy Below Lows, Sell Above Highs

The entire strategy reduces to one sentence: wait for liquidity to be swept at a structural extreme, then enter after the sweep in the direction of the opposing liquidity pool. Every other concept — market structure, order blocks, fair value gaps, Fibonacci — is secondary. They exist only to confirm where liquidity pools are accumulating, not to generate entry signals independently.

The structure must follow this sequence:

Extreme taken: A high is broken to the upside (inducing buyers) or a low is broken to the downside (inducing sellers).
Opposite respected: Price returns to the opposite extreme (e.g., returns to the low after taking the high) and respects it — meaning it reacts and moves away. This respect tells you there are resting orders at that level.
Sweep and reverse: Price now sweeps the respected extreme — below that low, or above that high. This triggers retail stops. The trap is set.
Entry in trap zone: Enter immediately after the sweep of the trapped retail stops.
Target opposing liquidity: The opposing structural extreme where the first batch of retail entries (from step 1) are sitting with their stops.

Step	Buy Setup (Long)	Sell Setup (Short)
1. Extreme Taken	High broken — induces buyers	Low broken — induces sellers
2. Opposite Respected	Return to low — price bounces off it	Return to high — price rejects from it
3. Sweep	Low broken — trapped buyers stopped out	High broken — trapped sellers stopped out
4. Entry	Buy below the swept low	Sell above the swept high
5. Stop-Loss	Below the structural low of the trap	Above the structural high of the trap
6. Target	Opposing liquidity above — previous highs	Opposing liquidity below — previous lows

3. What Is Liquidity — A Quant Definition

In trading, liquidity is simply resting orders. Stop-losses, limit orders, pending entries — clustered at structural extremes. When price approaches a level that has been respected previously, traders commit capital there. Their stop-losses sit just beyond. When price breaks that level, those stops are triggered, providing the counterparty fill that moves price further.

Liquidity Type	Where It Sits	What Creates It	How to Identify
Sell-Side Liquidity	Below structural lows	Buyer stop-losses, pending buy limits	Low respected → move away = liquidity below
Buy-Side Liquidity	Above structural highs	Seller stop-losses, pending sell limits	High respected → move away = liquidity above
Internal Liquidity	Swing points inside range	Lower TF entries, scalper stops	Use for partial exits / trade management
External Liquidity	Range extremes	Swing traders, position stops	Higher TF structural breaks (4H/Daily)
Induced Liquidity	Freshly built by false reactions	Trap moves that look like momentum	False BOS → retrace → liquidity builds at extreme

Critical Quant Insight: Not every high has liquidity above it, and not every low has liquidity below it. A level only has liquidity if it was first respected and then moved away from. If price broke through without a reaction, no orders accumulated there. The mere existence of a swing high or low does not guarantee trapped traders.

4. The 3-Step Directional Bias Framework

Direction is the hardest part. Most traders enter the right trade in the wrong direction because they lack a systematic method for determining bias. This framework answers three questions in sequence:

#	Question	What to Check	Decision
1	Where are the nearest opposing liquidity pools?	Mark all structural highs and lows on 4H/Daily. Every high that respected a previous high = buy-side liquidity above. Every low that respected a previous low = sell-side liquidity below.	If nearest is above → bullish bias. If nearest is below → bearish bias.
2	Has the intermediate extreme been swept?	On the entry timeframe (15min-1H), has the previous swing high (for buys) or swing low (for sells) been taken out? Was it respected first?	Swept + respected = ready. Not swept = wait. Never swept = no trade.
3	Is there a false reaction to confirm the trap?	Price broke out, then retraced back into the level, and the reaction at that level looks like a reversal to retail. This is the false move that builds the final liquidity pool.	False reaction confirmed = enter. No reaction = wait for structure to develop.

Quant Developer Note: This framework is algorithmic. Each step is a binary condition — the high was swept or not, the low was respected or not, the false reaction occurred or not. This makes it directly translatable to MQL5 logic with no ambiguity.

5. XAUUSD Detailed Walkthrough

Gold is the ideal instrument for this strategy. XAUUSD volatility creates clean structural swings. Session overlaps (London/NY) produce the highest concentration of trapped retail stops. Let us walk through a complete long setup on XAUUSD H1.

Setup Context — XAUUSD H1

Gold has been in an uptrend on the 4H chart. Price took out a previous swing high at 2,680 — inducing buyers. It then retraced to the previous swing low at 2,645 and respected it (bounced 30 pips away). This tells us: liquidity exists below 2,645 (buyer stops from the bounce).

Step	XAUUSD Action	Institutional Logic
1. Higher TF Bias	4H uptrend. High at 2,680 swept. Nearest opposing liquidity above = 2,680 → 2,710 (previous swing highs).	Bullish direction confirmed. Target zone: 2,680–2,710.
2. Intermediate Low Respected	H1 low at 2,645 respected twice — price bounced from it at London open, then again during NY pre-market.	Sell-side liquidity pool built at 2,645. Buyers accumulating stops below.
3. False Reaction (Trap)	Price spikes up to 2,660, takes out an internal high, then reverses sharply below 2,645 — wick through the low, closes below.	Internal high sweep induced fresh buyers. Their stops below 2,645 just got taken. More fuel added below the low.
4. Execution	Market buy after 5-min close above 2,643. Entry = 2,643.50.	Lows swept. Retail trapped short. Reversal begins.
5. Stop-Loss	SL at 2,640 (below the sweep low). Risk = 35 pips on XAUUSD (350 points).	If this low breaks again, the trap failed — exit.
6. Partial Exit	50% at 2,660 (internal high — trapped seller stops).	Internal liquidity hit. Lock in profit. +165 pips (1,650 points) on partial.
7. Final Target	Remaining 50% at 2,680 (external high — swing high where sellers are trapped). SL trailed below each new structural low.	External liquidity taken. Full target. +365 pips (3,650 points) on remaining.

XAUUSD Setup Summary

Total risk: 350 points (35 pips). Partial RR: 1:4.7. Final RR: 1:10.4. Why this wins: The entry is placed where retail stops have just been consumed. There is no one left to sell. The path of least resistance is upward to the next pool of resting orders.

Failed XAUUSD Setup — What to Avoid

A common failure: price takes out a high, retraces to the low, does not respect it, and continues through. The low was never respected — therefore no liquidity was built below it. When price breaks through, there are no trapped stops to sweep. The setup is invalid.

Rule: If the low was never respected, liquidity does not exist there. Do not buy below it. Do not sell above an unrespected high. Wait for the respect to occur first.

6. EURUSD Detailed Walkthrough

EURUSD provides a different challenge: lower volatility, tighter ranges, and more false breaks that require stricter filtering. The session timing becomes critical — London open (07:00 GMT) and NY open (13:00 GMT) are the windows where trapped stops concentrate.

Setup Context — EURUSD H1 Sell Setup

EURUSD has been in a daily downtrend. The 1.0940 low was taken, but the 1.0895 low was then respected twice (bounced mid-week during London session). This tells us: sell-side liquidity was consumed at 1.0940, and buy-side liquidity now sits above 1.0895 (seller stops). We want to sell above the 1.0895 high to catch trapped sellers.

Step	EURUSD Action	Institutional Logic
1. Higher TF Bias	Daily downtrend confirmed. Sell-side liquidity at 1.0940 swept. Target = 1.0850 (structural low from 2 weeks prior).	Bearish direction. Target: 1.0850. ADR = 65 pips, so this is a 2-day target.
2. Intermediate High Respected	H1 high at 1.0895 respected — price rejected from it on 3 consecutive H1 candles during London.	Buy-side liquidity pool built above 1.0895. Seller stops accumulating.
3. False Reaction (Trap)	NY open — price drops to 1.0875, breaks an internal low, induces sellers. Then reverses up, spikes through 1.0898 (high swept + 3 pips).	Sellers induced at the internal low break. Their stops above 1.0895 just got taken. Liquidity consumed.
4. Execution	Market sell at 1.0898 as price rejects from above 1.0900 (high swept, sellers trapped).	Enter above the swept high. Stop-loss covers the high.
5. Stop-Loss	SL at 1.0915 (above the structural high). Risk = 17 pips. Account for EURUSD spread (0.8-1.2 pips typical).	If buyers push above this, the structure invalidates.
6. Partial Exit	50% at 1.0875 (internal low — trapped buyer stops). +23 pips.	Internal sell-side liquidity consumed. Risk-free after this exit.
7. Final Target	Remaining 50% at 1.0850. SL trailed above each new structural high on H1.	External low hit. Total +48 pips on remaining portion.

EURUSD Setup Summary

Total risk: 17 pips. Partial RR: 1:1.35. Final RR: 1:2.8. Why this wins: The entry is above where retail shorts just got stopped out. Their forced buying just occurred. Now selling pressure resumes with no opposing buy orders above.

7. Internal vs External Liquidity — The Quant Distinction

This framework distinguishes between two types of liquidity pools, and knowing which to use for entries versus targets is what separates a profitable system from a directionally correct but unprofitable one.

Aspect	Internal Liquidity	External Liquidity
Definition	Swing points within the current range leg	The extreme high or low of the entire range
Timeframe	Lower TF (M15-H1)	Higher TF (H4-Daily-Weekly)
Role in Strategy	Use for trade management: partial exits, trailing stops, and gauge of remaining momentum	Use for ultimate target and directional bias confirmation
How to Identify	Look for smaller swing highs/lows printed after the external extreme was established	The furthest swing point on the higher timeframe before price reversed
Reversal Signal	False reactions at internal levels often fail quickly — do not trust them	Reactions at external levels are higher probability and often generate reversals
Entry Timing	Enter after internal liquidity is swept (the trap formation on lower TF)	Target only; do not enter from external levels alone (no trap, no trade)

Quant Rule: Enter from swept internal liquidity, target external liquidity. Never reverse this order. Entering at external without internal confirmation is gambling on a reversal without proof of trapped orders.

8. Strict Rules That Keep You Safe

The difference between a disciplined liquidity trader and a pattern gambler is the willingness to enforce these rules without exception. Every rule below protects against a specific failure mode.

#	Rule	Why It Exists
1	Never buy until the structural low is taken out	Prevents buying into a level where liquidity hasn't been swept yet — you would be providing exit liquidity to trapped longs
2	Never sell until the structural high is taken out	Prevents shorting into a level that still has resting buy-side liquidity waiting to drive price higher
3	If the opposing extreme was never respected, no trade	No respect = no resting orders accumulated = no trapped traders = no edge
4	Stop-loss always above/below the structural extreme of the trap	If the trap level itself is broken, the structure invalidated — exit immediately
5	Target only opposing liquidity pools — never arbitrary RR levels	Arbitrary RR exits ignore the core reason price moves: it chases resting orders. Exit at the next liquidity pool or not at all
6	Trade only during your defined session window	Outside high-liquidity windows, false breaks are less reliable and trapped order volume is lower
7	No more than 2–3 pairs on watchlist	With this system, 2-3 pairs produce 5-8 tradeable setups per week. More pairs = lower quality per setup
8	Trail stop below each new structural low (longs) / above each new structural high (shorts)	Locks in profit as the trade progresses without cutting winners prematurely

9. MQL5 EA Automation: Architecture & Code

This strategy is algorithmically translatable. Every rule is a binary condition: a level was swept or not, respected or not, false reaction occurred or not. Below is the complete architecture for an MQL5 Expert Advisor that automates the full liquidity-trap detection, entry, and trade management logic.

EA Architecture

Module	Responsibility	Key Functions
Structure Detector	Identify swing highs/lows on configurable TF. Track respect/sweep events.	DetectSwingPoints(), CheckLevelRespected(), CheckLevelSwept()
Liquidity Engine	Map buy-side and sell-side liquidity pools. Classify as internal/external.	MapLiquidityPools(), GetNearestLiquidity(), ClassifyInternalExternal()
Trap Detector	Detect false reactions at structural levels. Confirm BOS-inducement pattern.	DetectFalseReaction(), ValidateBOSStructure(), ConfirmTrapLevel()
Execution Engine	Place market orders at trap level breakthrough. Position sizing by ATR.	ExecuteLongBelowLow(), ExecuteShortAboveHigh(), CalcPositionSize()
Trade Manager	Trail stop-loss to new structural levels. Partial exits at internal liquidity hits.	TrailStopToNewLow(), PartialExitAtInternal(), CloseAtExternal()
Session Filter	Restrict entries to defined time window. Block outside session.	IsInSession(), IsNewsBlackout(), IsFridayCloseNear()

Core Detection Logic — MQL5

The engine below detects whether a structural level was respected and whether liquidity has been swept — the two conditions required before any entry signal is generated.

LiquidityTrapEA.mq5

//+------------------------------------------------------------------+
//| LiquidityTrapEA.mq5 — Automated Liquidity Trap Detection         |
//| Buy below swept lows. Sell above swept highs.                   |
//| Modular architecture: Structure → Liquidity → Trap → Entry      |
//+------------------------------------------------------------------+
#property strict
#property description "Liquidity Trap EA — institutional order flow automation"

input group "Structure Detection"
input int    InpSwingPeriod = 10;        // Swing high/low detection period
input double InpRespectThreshold = 5;    // Pips to confirm respect (bid proximity)
input double InpSweepThreshold = 2;      // Pips beyond level to confirm sweep

input group "Session & Timing"
input int    InpSessionStartHour = 7;    // GMT session start (7 = London)
input int    InpSessionEndHour = 16;     // GMT session end (16 = NY close)
input bool   InpNewsBlackout = true;     // Skip trades during high-impact news
input int    InpNewsBlackoutMinutes = 3; // Minutes before/after news to block

input group "Risk Management"
input double InpRiskPercent = 0.5;       // Risk per trade (% of equity)
input double InpMaxDailyLoss = 4.5;      // Hard stop daily loss %
input bool   InpPartialExit = true;      // Enable partial exits at internal liquidity
input double InpPartialPercent = 50;     // % of position to close at internal target

//--- Global structure tracking
struct SwingPoint {
    datetime time;
    double   price;
    int      type;       // 1 = high, -1 = low
    bool     respected;  // Has price reacted and moved away from this level?
    bool     swept;      // Has price broken through this level?
    bool     isExternal; // On higher TF?
};

struct LiquidityPool {
    double   price;
    int      direction;  // 1 = buy-side (above), -1 = sell-side (below)
    bool     isInternal; // Internal (M15-H1) or External (H4+)
    datetime created;
    int      respectCount; // How many times price respected this level
};

SwingPoint    g_swings[];
LiquidityPool g_pools[];
bool          g_hasPosition = false;
double        g_entryPrice = 0;
double        g_stopLoss = 0;

//+------------------------------------------------------------------+
//| Detect swing highs/lows using fractal pattern (3-candle)         |
//+------------------------------------------------------------------+
void DetectSwingPoints(string symbol, ENUM_TIMEFRAMES tf) {
    int period = InpSwingPeriod;
    MqlRates rates[];
    int copied = CopyRates(symbol, tf, 0, period * 3 + 1, rates);
    if(copied < period * 3) return;

    for(int i = period; i < copied - period; i++) {
        bool isHigh = true, isLow = true;
        for(int j = 1; j <= period; j++) {
            if(rates[i].high <= rates[i - j].high || rates[i].high <= rates[i + j].high)
                isHigh = false;
            if(rates[i].low >= rates[i - j].low || rates[i].low >= rates[i + j].low)
                isLow = false;
        }

        if(isHigh) {
            ArrayResize(g_swings, ArraySize(g_swings) + 1);
            g_swings[ArraySize(g_swings) - 1].time = rates[i].time;
            g_swings[ArraySize(g_swings) - 1].price = rates[i].high;
            g_swings[ArraySize(g_swings) - 1].type = 1;
            g_swings[ArraySize(g_swings) - 1].respected = false;
            g_swings[ArraySize(g_swings) - 1].swept = false;
        }
        if(isLow) {
            ArrayResize(g_swings, ArraySize(g_swings) + 1);
            g_swings[ArraySize(g_swings) - 1].time = rates[i].time;
            g_swings[ArraySize(g_swings) - 1].price = rates[i].low;
            g_swings[ArraySize(g_swings) - 1].type = -1;
            g_swings[ArraySize(g_swings) - 1].respected = false;
            g_swings[ArraySize(g_swings) - 1].swept = false;
        }
    }
}

//+------------------------------------------------------------------+
//| Check if a swing level has been respected (approached + reacted) |
//+------------------------------------------------------------------+
void CheckRespectAndSweep(string symbol, ENUM_TIMEFRAMES tf) {
    MqlRates rates[];
    int copied = CopyRates(symbol, tf, 0, 500, rates);
    if(copied < 2) return;

    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double currentBid = SymbolInfoDouble(symbol, SYMBOL_BID);
    double currentAsk = SymbolInfoDouble(symbol, SYMBOL_ASK);

    for(int s = 0; s < ArraySize(g_swings); s++) {
        // Check if level was respected: price approached within threshold and moved away
        for(int i = 1; i < copied - 1; i++) {
            double proximity = MathAbs(rates[i].close - g_swings[s].price) / point;
            if(proximity <= InpRespectThreshold * 10 && !g_swings[s].respected) {
                // Check if subsequent candles moved away
                double moveAway = (rates[i + 1].close - rates[i].close) / point;
                // For a high: price should fall away. For a low: price should rise away.
                if((g_swings[s].type == 1 && moveAway < -InpRespectThreshold * 5) ||
                   (g_swings[s].type == -1 && moveAway > InpRespectThreshold * 5)) {
                    g_swings[s].respected = true;
                }
            }
        }

        // Check if level was swept: price broke through
        if(g_swings[s].type == 1 && currentBid > g_swings[s].price + InpSweepThreshold * point * 10)
            g_swings[s].swept = true;
        if(g_swings[s].type == -1 && currentAsk < g_swings[s].price - InpSweepThreshold * point * 10)
            g_swings[s].swept = true;
    }
}

//+------------------------------------------------------------------+
//| Map liquidity pools from respected swing points                  |
//+------------------------------------------------------------------+
void MapLiquidityPools() {
    ArrayResize(g_pools, 0);

    for(int i = 0; i < ArraySize(g_swings); i++) {
        if(!g_swings[i].respected) continue; // Skip unrespected levels — no liquidity

        ArrayResize(g_pools, ArraySize(g_pools) + 1);
        g_pools[ArraySize(g_pools) - 1].price = g_swings[i].price;
        g_pools[ArraySize(g_pools) - 1].direction = g_swings[i].type;
        g_pools[ArraySize(g_pools) - 1].created = g_swings[i].time;
        g_pools[ArraySize(g_pools) - 1].respectCount = 1;

        // Classify as internal or external (simplified: H4+ = external)
        g_pools[ArraySize(g_pools) - 1].isInternal = true; // Default
    }
}

//+------------------------------------------------------------------+
//| Detect false reaction trap: BOS → retrace → sweep at extreme    |
//+------------------------------------------------------------------+
bool DetectTrapSetup(int direction) {
    // direction: 1 = looking for buy trap (below lows), -1 = sell trap (above highs)

    // Step 1: Find most recent respected extreme
    int extremeIndex = -1;
    for(int i = ArraySize(g_swings) - 1; i >= 0; i--) {
        if(g_swings[i].type == -direction && g_swings[i].respected) {
            extremeIndex = i;
            break;
        }
    }
    if(extremeIndex == -1) return false;

    // Step 2: Check if a BOS occurred (higher high for buys, lower low for sells)
    bool bos = false;
    for(int i = extremeIndex + 1; i < ArraySize(g_swings); i++) {
        if(direction == 1 && g_swings[i].type == 1 && g_swings[i].price > g_swings[extremeIndex].price)
            bos = true;
        if(direction == -1 && g_swings[i].type == -1 && g_swings[i].price < g_swings[extremeIndex].price)
            bos = true;
    }

    // Step 3: Check if the extreme level has now been swept (trap complete)
    if(bos && g_swings[extremeIndex].swept) {
        // Step 4: Find opposing liquidity to target
        for(int i = 0; i < ArraySize(g_pools); i++) {
            if(g_pools[i].direction == direction) {
                return true; // Valid trap setup: extreme swept, opposing pool exists
            }
        }
    }
    return false;
}

//+------------------------------------------------------------------+
//| Execute a long entry below the swept low                         |
//+------------------------------------------------------------------+
bool ExecuteLongBelowLow(string symbol) {
    if(!DetectTrapSetup(1)) return false;
    if(!IsInSession()) return false;
    if(g_hasPosition) return false;

    double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double equity = AccountInfoDouble(ACCOUNT_EQUITY);
    double riskAmount = equity * InpRiskPercent / 100;

    // Find the swept low to place stop below
    double sweptLow = 0;
    for(int i = ArraySize(g_swings) - 1; i >= 0; i--) {
        if(g_swings[i].type == -1 && g_swings[i].swept && g_swings[i].respected) {
            sweptLow = g_swings[i].price;
            break;
        }
    }
    if(sweptLow == 0) return false;

    double stopDist = (ask - sweptLow) + 20 * point; // 20 points buffer
    double lotSize = riskAmount / (stopDist * SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE));

    // Round lot size
    double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
    lotSize = MathFloor(lotSize / lotStep) * lotStep;
    if(lotSize <= 0) return false;

    MqlTradeRequest req = {};
    MqlTradeResult res = {};
    req.action = TRADE_ACTION_DEAL;
    req.symbol = symbol;
    req.volume = lotSize;
    req.type = ORDER_TYPE_BUY;
    req.price = ask;
    req.sl = sweptLow - 10 * point;
    req.deviation = 50;
    req.magic = 20260720;
    req.comment = "Liquidity Trap Long";

    if(OrderSend(req, res) && res.retcode == TRADE_RETCODE_DONE) {
        g_hasPosition = true;
        g_entryPrice = ask;
        g_stopLoss = sweptLow;
        Print("Long entry executed at ", ask, " | SL: ", sweptLow, " | Lot: ", lotSize);
        return true;
    }
    return false;
}

//+------------------------------------------------------------------+
//| Session filter — only trade during configured hours (GMT)        |
//+------------------------------------------------------------------+
bool IsInSession() {
    datetime now = TimeCurrent();
    MqlDateTime dt;
    TimeToStruct(now, dt);

    int serverGMTOffset = (int)(TimeGMTOffset() / 3600);
    int currentGMT = dt.hour - serverGMTOffset;
    if(currentGMT < 0) currentGMT += 24;
    if(currentGMT > 23) currentGMT -= 24;

    if(currentGMT >= InpSessionStartHour && currentGMT < InpSessionEndHour)
        return true;
    return false;
}

//+------------------------------------------------------------------+
//| Trail stop-loss to each new structural low (long positions)      |
//+------------------------------------------------------------------+
void TrailStopBelowNewLow(string symbol) {
    if(!g_hasPosition) return;
    if(!PositionSelect(symbol)) return;

    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double currentSL = PositionGetDouble(POSITION_SL);
    double currentBid = SymbolInfoDouble(symbol, SYMBOL_BID);

    // Find the most recent swing low that is BELOW current price
    for(int i = ArraySize(g_swings) - 1; i >= 0; i--) {
        if(g_swings[i].type == -1 && g_swings[i].price < currentBid) {
            double newSL = g_swings[i].price - 10 * point;
            if(newSL > currentSL) {
                // Move stop up — never down
                MqlTradeRequest req = {};
                MqlTradeResult res = {};
                req.action = TRADE_ACTION_SLTP;
                req.symbol = symbol;
                req.sl = newSL;
                req.position = PositionGetInteger(POSITION_TICKET);
                OrderSend(req, res);
            }
            break;
        }
    }
}

//+------------------------------------------------------------------+
void OnTick() {
    string symbol = _Symbol;
    ENUM_TIMEFRAMES tf = PERIOD_H1;

    // Run detection every new bar
    static datetime lastCheck = 0;
    datetime barTime = iTime(symbol, tf, 0);
    if(barTime == lastCheck) return;
    lastCheck = barTime;

    DetectSwingPoints(symbol, tf);
    CheckRespectAndSweep(symbol, tf);
    MapLiquidityPools();

    // Attempt entry
    if(!g_hasPosition) {
        ExecuteLongBelowLow(symbol);
    }

    // Manage existing position
    if(g_hasPosition) {
        TrailStopBelowNewLow(symbol);
    }
}
//+------------------------------------------------------------------+

How to Use the EA

Copy to MQL5\Experts\LiquidityTrapEA.mq5 — compile with F7
Set InpSwingPeriod for your timeframe (H1 = 10, M15 = 20, M5 = 40)
Set InpSessionStartHour and InpSessionEndHour for your preferred trading window (GMT)
Set InpRiskPercent between 0.3 and 0.5 for prop firm compatibility
Forward-test on demo for minimum 2 weeks before live deployment
Run a backtest on tick data with realistic spread modeling — the strategy tester will show you exactly how often setups occur and their win rate

10. Adapting the Strategy for Prop Firms

The Liquidity Trap strategy is naturally compatible with prop firm evaluation rules because of its low trade frequency and structured entries. However, specific adjustments are required.

Prop Firm Rule	Impact on Strategy	Adjustment
Max Daily Loss (5% FTMO)	With 0.5% risk per trade, this allows 10 consecutive losses — highly unlikely with this system	Hard-code 4.5% daily loss cutoff. The EA already has InpMaxDailyLoss.
Consistency Score	The strategy naturally produces consistent results because setups are structural, not luck-based. 2-4 trades/week.	Track daily P&L. Cap daily profit at 1.5% to prevent a single day dominating.
News Blackout (3 min)	High-impact news can cause sharp spikes that sweep levels prematurely	The EA has InpNewsBlackout and InpNewsBlackoutMinutes. Use a live economic calendar feed.
No Martingale / Grid	Naturally compliant — this system uses exactly one entry per setup. No averaging.	No adjustment needed. Single entry, single trade, hard stop.

11. Frequently Asked Questions

How do I know if a level was "respected"?

A level is respected when price approaches within a few pips, reacts visibly (a candle wick rejection or a strong-momentum move away), and does not break through on that first touch. The key indicator: the level causes price to change direction, even temporarily.

What timeframe should I use?

Bias from H4/Daily. Entry and trap detection from H1/15-min. Execution on M5. The fractal nature means the same rules apply on any timeframe — you choose the one that matches your holding period (day trade, swing, or scalp).

How many trades per week can I expect?

With 2-3 pairs (e.g., XAUUSD, EURUSD, US30) you will see 5-8 valid setups per week on average. Some weeks produce fewer — and that is fine. Not trading a low-probability week is part of the edge.

What if price runs away without sweeping my level?

Then the trade was never yours to take. The untouched level becomes a future target — it will likely be run within days or weeks as liquidity accumulates elsewhere. Patience is the hardest and most profitable skill in this system.

Can I use this strategy on indices?

Yes. The strategy was developed on futures indices (YM, NQ). Indices work exceptionally well because of the concentrated volume around stock market open (9:30 AM NY). The same liquidity-trap logic applies identically.

Does this work on crypto?

The framework applies, but crypto lacks centralized order books. The liquidity pool measurement is less precise. Forex and futures are recommended for clean execution.

How do I handle failed setups?

A failure means the trap level was swept but price continued in the wrong direction. Your stop-loss covers the structural extreme — if that breaks, the structure changed. Exit immediately. Do not re-enter until a new respected structure forms.

Automate Your Liquidity Trap Strategy

The EA architecture above is a starting point. Need a fully backtested, prop-firm-compliant MQL5 Expert Advisor built around your exact liquidity rules? We build custom EAs with hard risk controls, walk-forward validation, and full source code.

Get a Fixed-Price Quote