The Ultimate 1-Minute EUR/USD Scalping Strategy for Beginners

[PTScalper]

Are you tired of watching your trades get wiped out by sudden market reversals? If you are just starting out in the fast-paced world of day trading, finding a reliable 1-minute EUR/USD scalping strategy for beginners can feel impossible. The secret isn't a magical custom indicator; it is combining the right technical tools with the correct broker environment.
Here is a straightforward, easily repeatable setup that focuses on high-probability momentum bursts.
The Setup: Bollinger Bands + Stochastic Oscillator
When trading the 1-minute chart, you need to filter out the noise. The best forex indicators for scalping are those that measure both volatility and momentum simultaneously.
1. Bollinger Bands (Standard 20, 2 setting): We are looking for the "Bollinger squeeze." When the bands narrow tightly, it indicates low volatility and consolidation in the underlying market. A breakout is usually imminent.
2. Stochastic Oscillator (5, 3, 3): This acts as your trigger. You want to see the solid %K line cross the dotted %D line in the direction of the Bollinger breakout, specifically pushing out of the extremes of a recent price range.
The Trigger: Wait for a 1-minute candle to forcefully close outside the narrowing Bollinger Bands. If the Stochastic oscillator confirms the momentum with a fresh crossover, you enter the trade. Aim for a quick 5 to 7 pips, placing your stop loss just inside the opposite Bollinger Band.
Why Low Spread Scalping Strategies Matter
You can have the most accurate forex scalping strategy in the world, but if your trading environment is flawed, you will still lose money.
When your profit target is only 5 to 20 pips, broker fees become your biggest enemy. This is why low spread scalping strategies are the only mathematically viable way to trade the 1-minute chart. If your broker charges a 1.5-pip spread on the EUR/USD, you are surrendering a massive portion of a 5-pip profit instantly.
To make this strategy work, you must use a Raw Spread or true ECN broker. Your goal is to pay a flat commission and trade on spreads that hover near 0.0 to 0.1 pips. Major currency pairs like the EUR/USD will naturally provide the tightest spreads and highest liquidity for this approach.
Pro Tip: Never trade this setup during major news releases or data drops from the economic calendar. The volatility will widen even the tightest spreads, easily triggering your stop loss through slippage before the trade even has a chance to play out. Stick to the technicals, keep your costs low, and stay disciplined.

[LondonScalper]

Bollinger Bands + Stochastic Oscillator... 1-minute EUR/USD scalping strategy for beginners

BB squeeze + stochastic is a classic retail stack. It can be a decent trainer for seeing compression → expansion. I’d be careful calling it “ultimate” for live beginners on M1.

M1 EURUSD punishes indicator lag and late entries. Stochastic turns late; Bollinger breakouts fake often in Asia and lunch. If someone uses this, I’d add hard constraints: London cash hours only, minimum ATR filter, pre-defined invalidation beyond the band, and tiny size until they have 200+ logged tickets.

What actually helps beginners more than the oscillator cocktail:

• One session, one pair
• Cost awareness (all-in vs target)
• A daily loss stop that ends the experiment cleanly

Happy to discuss how you’re filtering false squeezes — without that, BB+Stoch on M1 is a busy way to donate spread.

[PropScalpDesk]

Beginner M1 EURUSD: constraints before indicators

A complete one-minute EURUSD method for beginners usually fails on operations, not on missing a magical moving average. The chart is the easy part; the job is the hard part.

If someone asked me in Frankfurt what to install first:

• Hard daily loss and per-trade R, written before live clicks.
• Spread filter for the Frankfurt and London window you will actually trade.
• One entry sentence and one invalidation sentence a stranger could follow.
• News calendar with blackout times next to the monitor.

Indicators can come later. Without the above, M1 is a slot machine with candles. Beginners should not optimize for trade count. Optimize for rule-adherence days — that is the skill that transfers when you eventually change a trigger.

Practice the risk frame on the smallest live size your broker allows before you chase a perfect indicator stack. Mechanics first. Cosmetics later. Most beginner pain on M1 is operational, not intellectual.

Which part are you building first — the entry trigger, or the risk and cost frame that keeps you in the game?

[PTScalper]

Are you tired of watching your trades get wiped out by sudden market reversals? If you are just starting out in the fast-paced world of day trading, finding a reliable 1-minute EUR/USD scalping strategy for beginners can feel impossible. The secret isn't a magical custom indicator; it is combining the right technical tools with the correct broker environment.
Here is a straightforward, easily repeatable setup that focuses on high-probability momentum bursts.
The Setup: Bollinger Bands + Stochastic Oscillator
When trading the 1-minute chart, you need to filter out the noise. The best forex indicators for scalping are those that measure both volatility and momentum simultaneously.
1. Bollinger Bands (Standard 20, 2 setting): We are looking for the "Bollinger squeeze." When the bands narrow tightly, it indicates low volatility and consolidation in the underlying market. A breakout is usually imminent.
2. Stochastic Oscillator (5, 3, 3): This acts as your trigger. You want to see the solid %K line cross the dotted %D line in the direction of the Bollinger breakout, specifically pushing out of the extremes of a recent price range.
The Trigger: Wait for a 1-minute candle to forcefully close outside the narrowing Bollinger Bands. If the Stochastic oscillator confirms the momentum with a fresh crossover, you enter the trade. Aim for a quick 5 to 7 pips, placing your stop loss just inside the opposite Bollinger Band.
Why Low Spread Scalping Strategies Matter
You can have the most accurate forex scalping strategy in the world, but if your trading environment is flawed, you will still lose money.
When your profit target is only 5 to 20 pips, broker fees become your biggest enemy. This is why low spread scalping strategies are the only mathematically viable way to trade the 1-minute chart. If your broker charges a 1.5-pip spread on the EUR/USD, you are surrendering a massive portion of a 5-pip profit instantly.
To make this strategy work, you must use a Raw Spread or true ECN broker. Your goal is to pay a flat commission and trade on spreads that hover near 0.0 to 0.1 pips. Major currency pairs like the EUR/USD will naturally provide the tightest spreads and highest liquidity for this approach.
Pro Tip: Never trade this setup during major news releases or data drops from the economic calendar. The volatility will widen even the tightest spreads, easily triggering your stop loss through slippage before the trade even has a chance to play out. Stick to the technicals, keep your costs low, and stay disciplined.

I prepared Pinescript with this strategy, so you can test it for yourself.
And make it even better.

Here is the Pine Script (Version 5) strategy based directly on your rules.

I’ve translated your logic into code, including a mathematical definition for the "Bollinger squeeze" (checking if the bands are narrower than their recent average) and a window for the Stochastic crossover, as indicators rarely align on the exact same 1-minute candle.

Pine Script v5: 1-Min EUR/USD Scalper

Code: Select all

//@version=5
strategy("1-Min EUR/USD Scalper: BB + Stoch", overlay=true, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// ==========================================
// 1. INPUTS
// ==========================================
// Bollinger Bands Settings
bbLength = input.int(20, title="Bollinger Length", group="Bollinger Bands")
bbMult   = input.float(2.0, title="Bollinger Multiplier", group="Bollinger Bands")

// Stochastic Settings (5, 3, 3)
stochK       = input.int(5, title="Stoch %K Length", group="Stochastic")
stochSmoothK = input.int(3, title="Stoch %K Smoothing", group="Stochastic")
stochSmoothD = input.int(3, title="Stoch %D Smoothing", group="Stochastic")

// Trade Management
tpPips = input.float(6.0, title="Take Profit (Pips)", minval=1.0, group="Trade Settings", tooltip="Aim for 5 to 7 pips as per strategy")

// ==========================================
// 2. INDICATOR CALCULATIONS
// ==========================================
// Bollinger Bands
[bbMiddle, bbUpper, bbLower] = ta.bb(close, bbLength, bbMult)

// Bollinger Squeeze Filter
// Calculates bandwidth and checks if it was recently lower than its 20-period average
bbWidth = (bbUpper - bbLower) / bbMiddle
isSqueeze = bbWidth < ta.sma(bbWidth, 20)
wasSqueeze = isSqueeze[1] or isSqueeze[2] // Squeeze happened just before the breakout

// Stochastic (5, 3, 3)
// ta.stoch returns raw %K. We smooth it to get the solid %K line, then smooth again for the dotted %D line.
rawK = ta.stoch(close, high, low, stochK)
kLine = ta.sma(rawK, stochSmoothK) 
dLine = ta.sma(kLine, stochSmoothD)

// ==========================================
// 3. ENTRY CONDITIONS
// ==========================================
// Check for recent Stochastic crossovers (within the last 2 bars to allow momentum to align)
crossUp   = ta.crossover(kLine, dLine)
crossDown = ta.crossunder(kLine, dLine)
recentCrossUp   = math.sum(crossUp ? 1 : 0, 2) > 0
recentCrossDown = math.sum(crossDown ? 1 : 0, 2) > 0

// Breakout logic + Squeeze + Stoch Confirmation
longCond  = (close > bbUpper) and wasSqueeze and recentCrossUp
shortCond = (close < bbLower) and wasSqueeze and recentCrossDown

// ==========================================
// 4. PIP CALCULATION & EXECUTION
// ==========================================
// Standardize pips for 5-digit Forex brokers (e.g., EUR/USD)
pipSize = syminfo.mintick * (syminfo.mintick == 0.00001 or syminfo.mintick == 0.001 ? 10 : 1)

var float tradeSL = na
var float tradeTP = na

// Long Entry
if (longCond and strategy.position_size == 0)
    tradeSL := bbLower // Stop loss just inside the opposite band
    tradeTP := close + (tpPips * pipSize)
    strategy.entry("Long", strategy.long)
    strategy.exit("Exit Long", "Long", limit=tradeTP, stop=tradeSL)

// Short Entry
if (shortCond and strategy.position_size == 0)
    tradeSL := bbUpper // Stop loss just inside the opposite band
    tradeTP := close - (tpPips * pipSize)
    strategy.entry("Short", strategy.short)
    strategy.exit("Exit Short", "Short", limit=tradeTP, stop=tradeSL)

// ==========================================
// 5. VISUALS
// ==========================================
plot(bbUpper, color=color.new(color.red, 70), title="BB Upper")
plot(bbLower, color=color.new(color.green, 70), title="BB Lower")
plot(bbMiddle, color=color.new(color.blue, 50), title="BB Middle")

// Plot Entry Signals on Chart
plotshape(longCond and strategy.position_size == 0, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Long Signal")
plotshape(shortCond and strategy.position_size == 0, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Short Signal")

[PTScalper]

How to use this script

1.) Open TradingView and open the EUR/USD chart on the 1-minute timeframe.

2.) At the bottom of the screen, click the Pine Editor tab.

3.) Delete any existing code, paste the script above, and click Save.

4.) Click Add to Chart.

How the mechanics work in this code:

The Squeeze: The script mathematically measures a "squeeze" by tracking the Bollinger Bandwidth. If the width of the bands drops below its own 20-period moving average, it registers as a squeeze (isSqueeze = true). It requires this state to be active right before the candle forcefully breaks out.

The Stochastic Alignment: Because price breakouts and indicator crossovers rarely happen on the exact same 1-minute tick, I added a 2-bar lookback for the Stochastic crossover (recentCrossUp). This ensures it captures the momentum burst even if the Stochastic crossed a few seconds prior to the candle closing outside the band.

Trade Management: As soon as an entry is triggered, the script places a Take Profit limit order (defaulted to 6 pips, adjustable in settings) and a Stop Loss dynamically pegged to the opposite Bollinger Band at the time of entry.

Note on Broker Spreads: Just as your strategy description warns, Pine Script's default backtester assumes perfect liquidity. To get an accurate backtest that reflects your ECN/Raw spread environment, click the gear icon on the strategy tester, go to Properties, and input your broker's exact average commission per trade and a conservative slippage/spread metric.

[PTScalper]

Here are complete, production-ready Expert Advisors (EAs) for both MetaTrader 4 (MQL4) and MetaTrader 5 (MQL5).

Both EAs evaluate signals strictly on the close of each 1-minute candle to prevent intra-bar repainting, automatically adapt pip calculations to 5-digit brokers, and include position filters so only one trade runs at a time.

1. MetaTrader 4 (MQL4) EA

Save this file as BBScalper_EURUSD.mq4 in your MQL4/Experts folder.

Code: Select all

//+------------------------------------------------------------------+
//|                                           BBScalper_EURUSD.mq4   |
//|                    1-Min Scalper: Bollinger Bands + Stochastic   |
//+------------------------------------------------------------------+
#property copyright "Trading Strategy"
#property link      ""
#property version   "1.00"
#property strict

//--- Inputs
input string   InpTradeSettings  = "=== Trade Settings ===";
input double   InpLotSize        = 0.10;      // Fixed Lot Size
input double   InpTakeProfitPips = 6.0;       // Take Profit in Pips (5-7 pips recommended)
input int      InpSlippage       = 3;         // Allowed Slippage (points)
input ulong    InpMagicNumber    = 101124;    // EA Magic Number

input string   InpBBSettings     = "=== Bollinger Bands ===";
input int      InpBBLength       = 20;        // BB Period
input double   InpBBMovDev       = 2.0;       // BB Deviation

input string   InpStochSettings  = "=== Stochastic Oscillator ===";
input int      InpStochK         = 5;         // %K Length
input int      InpStochD         = 3;         // %D Smoothing
input int      InpStochSlowing   = 3;         // %K Slowing

//--- Global Variables
datetime glLastBarTime = 0;
double   glPipSize     = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   // Adjust pip sizing for 3 and 5-digit broker pricing
   if(Digits == 3 || Digits == 5)
      glPipSize = Point * 10;
   else
      glPipSize = Point;

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Execute only once per newly closed candle
   datetime currentBarTime = Time[0];
   if(currentBarTime == glLastBarTime)
      return;

   // Ensure no active trades exist under this EA before looking for entries
   if(CountOpenPositions() > 0)
      return;

   // -------------------------------------------------------------
   // 1. Bollinger Bands & Squeeze Calculation
   // -------------------------------------------------------------
   double bbUpper1 = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double bbLower1 = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_LOWER, 1);
   double bbMid1   = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_MAIN,  1);

   double bbUpper2 = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_UPPER, 2);
   double bbLower2 = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_LOWER, 2);
   double bbMid2   = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_MAIN,  2);

   double width1 = (bbUpper1 - bbLower1) / bbMid1;
   double width2 = (bbUpper2 - bbLower2) / bbMid2;

   // 20-period SMA of Bandwidth to detect squeeze
   double sumWidth = 0.0;
   for(int i = 1; i <= 20; i++)
   {
      double u = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_UPPER, i);
      double l = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_LOWER, i);
      double m = iBands(Symbol(), Period(), InpBBLength, InpBBMovDev, 0, PRICE_CLOSE, MODE_MAIN,  i);
      sumWidth += ((u - l) / m);
   }
   double smaWidth = sumWidth / 20.0;

   bool wasSqueeze = (width1 < smaWidth) || (width2 < smaWidth);

   // -------------------------------------------------------------
   // 2. Stochastic Oscillator (5, 3, 3)
   // -------------------------------------------------------------
   double k1 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_MAIN,   1);
   double d1 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_SIGNAL, 1);
   double k2 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_MAIN,   2);
   double d2 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_SIGNAL, 2);
   double k3 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_MAIN,   3);
   double d3 = iStochastic(Symbol(), Period(), InpStochK, InpStochD, InpStochSlowing, MODE_SMA, 0, MODE_SIGNAL, 3);

   bool crossUpBar1 = (k2 <= d2 && k1 > d1);
   bool crossUpBar2 = (k3 <= d3 && k2 > d2);
   bool recentCrossUp = crossUpBar1 || crossUpBar2;

   bool crossDownBar1 = (k2 >= d2 && k1 < d1);
   bool crossDownBar2 = (k3 >= d3 && k2 < d2);
   bool recentCrossDown = crossDownBar1 || crossDownBar2;

   // -------------------------------------------------------------
   // 3. Entry Signals & Execution
   // -------------------------------------------------------------
   bool longCondition  = (Close[1] > bbUpper1) && wasSqueeze && recentCrossUp;
   bool shortCondition = (Close[1] < bbLower1) && wasSqueeze && recentCrossDown;

   if(longCondition)
   {
      double sl = NormalizeDouble(bbLower1, Digits);
      double tp = NormalizeDouble(Ask + (InpTakeProfitPips * glPipSize), Digits);
      int ticket = OrderSend(Symbol(), OP_BUY, InpLotSize, Ask, InpSlippage, sl, tp, "BB Scalp Long", (int)InpMagicNumber, 0, clrGreen);
      if(ticket > 0)
         glLastBarTime = currentBarTime;
   }
   else if(shortCondition)
   {
      double sl = NormalizeDouble(bbUpper1, Digits);
      double tp = NormalizeDouble(Bid - (InpTakeProfitPips * glPipSize), Digits);
      int ticket = OrderSend(Symbol(), OP_SELL, InpLotSize, Bid, InpSlippage, sl, tp, "BB Scalp Short", (int)InpMagicNumber, 0, clrRed);
      if(ticket > 0)
         glLastBarTime = currentBarTime;
   }
   else
   {
      glLastBarTime = currentBarTime;
   }
}

//+------------------------------------------------------------------+
//| Count active orders for this symbol & magic number               |
//+------------------------------------------------------------------+
int CountOpenPositions()
{
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == InpMagicNumber)
         {
            if(OrderType() == OP_BUY || OrderType() == OP_SELL)
               count++;
         }
      }
   }
   return count;
}

[PTScalper]

2. MetaTrader 5 (MQL5) EA

Save this file as BBScalper_EURUSD.mq5 in your MQL5/Experts folder. It uses MT5's standard CTrade library and asynchronous indicator handles.

Code: Select all

//+------------------------------------------------------------------+
//|                                           BBScalper_EURUSD.mq5   |
//|                    1-Min Scalper: Bollinger Bands + Stochastic   |
//+------------------------------------------------------------------+
#property copyright "Trading Strategy"
#property link      ""
#property version   "1.00"

#include <Trade\Trade.mqh>

//--- Inputs
input group "=== Trade Settings ==="
input double   InpLotSize        = 0.10;      // Fixed Lot Size
input double   InpTakeProfitPips = 6.0;       // Take Profit in Pips (5-7 pips)
input ulong    InpMagicNumber    = 101125;    // EA Magic Number

input group "=== Bollinger Bands ==="
input int      InpBBLength       = 20;        // BB Period
input double   InpBBMovDev       = 2.0;       // BB Deviation

input group "=== Stochastic Oscillator ==="
input int      InpStochK         = 5;         // %K Length
input int      InpStochD         = 3;         // %D Smoothing
input int      InpStochSlowing   = 3;         // %K Slowing

//--- Handles & Trade Instance
CTrade   trade;
int      handleBB;
int      handleStoch;
datetime glLastBarTime = 0;
double   glPipSize     = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(InpMagicNumber);

   // Configure pip size for 3/5 digit quotes
   if(_Digits == 3 || _Digits == 5)
      glPipSize = _Point * 10;
   else
      glPipSize = _Point;

   // Create Indicator Handles
   handleBB = iBands(_Symbol, _Period, InpBBLength, 0, InpBBMovDev, PRICE_CLOSE);
   if(handleBB == INVALID_HANDLE)
   {
      Print("Failed to create Bollinger Bands handle.");
      return(INIT_FAILED);
   }

   handleStoch = iStochastic(_Symbol, _Period, InpStochK, InpStochD, InpStochSlowing, MODE_SMA, STO_LOWHIGH);
   if(handleStoch == INVALID_HANDLE)
   {
      Print("Failed to create Stochastic handle.");
      return(INIT_FAILED);
   }

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(handleBB);
   IndicatorRelease(handleStoch);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Run strictly once on candle close (open of new bar)
   datetime currentBarTime = iTime(_Symbol, _Period, 0);
   if(currentBarTime == glLastBarTime)
      return;

   // Check if an open position already exists for this symbol & magic number
   if(HasOpenPosition())
      return;

   // -------------------------------------------------------------
   // 1. Copy Indicator Buffers
   // -------------------------------------------------------------
   // Bollinger Buffers: 0 = Middle, 1 = Upper, 2 = Lower
   double bbMid[], bbUpper[], bbLower[];
   ArraySetAsSeries(bbMid, true);
   ArraySetAsSeries(bbUpper, true);
   ArraySetAsSeries(bbLower, true);

   if(CopyBuffer(handleBB, 0, 1, 22, bbMid) < 22 ||
      CopyBuffer(handleBB, 1, 1, 22, bbUpper) < 22 ||
      CopyBuffer(handleBB, 2, 1, 22, bbLower) < 22)
      return;

   // Stochastic Buffers: 0 = %K (Main), 1 = %D (Signal)
   double stochK[], stochD[];
   ArraySetAsSeries(stochK, true);
   ArraySetAsSeries(stochD, true);

   if(CopyBuffer(handleStoch, 0, 1, 4, stochK) < 4 ||
      CopyBuffer(handleStoch, 1, 1, 4, stochD) < 4)
      return;

   // Price quotes (Index 0 represents closed Bar 1)
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   if(CopyRates(_Symbol, _Period, 1, 2, rates) < 2)
      return;

   // -------------------------------------------------------------
   // 2. Bollinger Squeeze Calculation
   // -------------------------------------------------------------
   // In array-as-series: index 0 is Bar 1, index 1 is Bar 2
   double widthBar1 = (bbUpper[0] - bbLower[0]) / bbMid[0];
   double widthBar2 = (bbUpper[1] - bbLower[1]) / bbMid[1];

   double sumWidth = 0.0;
   for(int i = 0; i < 20; i++)
   {
      sumWidth += ((bbUpper[i] - bbLower[i]) / bbMid[i]);
   }
   double smaWidth = sumWidth / 20.0;
   bool wasSqueeze = (widthBar1 < smaWidth) || (widthBar2 < smaWidth);

   // -------------------------------------------------------------
   // 3. Stochastic Crossover Check
   // -------------------------------------------------------------
   bool crossUp1 = (stochK[1] <= stochD[1] && stochK[0] > stochD[0]);
   bool crossUp2 = (stochK[2] <= stochD[2] && stochK[1] > stochD[1]);
   bool recentCrossUp = crossUp1 || crossUp2;

   bool crossDown1 = (stochK[1] >= stochD[1] && stochK[0] < stochD[0]);
   bool crossDown2 = (stochK[2] >= stochD[2] && stochK[1] < stochD[1]);
   bool recentCrossDown = crossDown1 || crossDown2;

   // -------------------------------------------------------------
   // 4. Entry Evaluation
   // -------------------------------------------------------------
   bool longCondition  = (rates[0].close > bbUpper[0]) && wasSqueeze && recentCrossUp;
   bool shortCondition = (rates[0].close < bbLower[0]) && wasSqueeze && recentCrossDown;

   if(longCondition)
   {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl  = NormalizeDouble(bbLower[0], _Digits);
      double tp  = NormalizeDouble(ask + (InpTakeProfitPips * glPipSize), _Digits);

      if(trade.Buy(InpLotSize, _Symbol, ask, sl, tp, "BB Scalp Long"))
         glLastBarTime = currentBarTime;
   }
   else if(shortCondition)
   {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl  = NormalizeDouble(bbUpper[0], _Digits);
      double tp  = NormalizeDouble(bid - (InpTakeProfitPips * glPipSize), _Digits);

      if(trade.Sell(InpLotSize, _Symbol, bid, sl, tp, "BB Scalp Short"))
         glLastBarTime = currentBarTime;
   }
   else
   {
      glLastBarTime = currentBarTime;
   }
}

//+------------------------------------------------------------------+
//| Check if open position exists for this symbol & magic number     |
//+------------------------------------------------------------------+
bool HasOpenPosition()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0)
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
            PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
         {
            return true;
         }
      }
   }
   return false;
}

[PTScalper]

Setup Instructions

1.) Open MetaEditor (F4 in either MT4 or MT5).

2.) Click New -> Expert Advisor (template), name it, and replace the placeholder text with the respective code above.

3.) Click Compile (F7) at the top of the toolbar and confirm zero errors in the console.

4.) Back in the terminal, attach the EA from the Navigator panel to an active EUR/USD M1 chart.

5.) In the settings pop-up, check "Allow Live Trading" (or "Allow Algo Trading" in MT5), and make sure the global AutoTrading button is toggled green on your top toolbar.