Bollinger Bands Trading Strategy: Complete Guide with Code

//@version=5
strategy("BB Bounce Strategy", overlay=true)

// Bollinger Bands Settings
length = input(20, "BB Length")
mult = input.float(2.0, "BB Multiplier")
rsiLength = input(14, "RSI Length")

// Calculate Bollinger Bands
basis = ta.sma(close, length)
dev = mult * ta.stdev(close, length)
upper = basis + dev
lower = basis - dev

// RSI for confirmation
rsiValue = ta.rsi(close, rsiLength)

// Buy at lower band when RSI confirms oversold
longCondition = close <= lower and rsiValue < 30
if (longCondition)
    strategy.entry("Long", strategy.long)

// Exit at middle band or upper band
if (close >= basis)
    strategy.close("Long")

// Plot bands
plot(basis, "Basis", color=color.blue)
plot(upper, "Upper", color=color.red)
plot(lower, "Lower", color=color.green)

//+------------------------------------------------------------------+
//| Bollinger Bounce EA                                               |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>

input int BB_Period = 20;
input double BB_Deviation = 2.0;
input int RSI_Period = 14;
input double LotSize = 0.1;
input int StopLossPips = 40;

CTrade trade;
int bbHandle, rsiHandle;

int OnInit()
{
    bbHandle = iBands(_Symbol, PERIOD_CURRENT, BB_Period, 0, BB_Deviation, PRICE_CLOSE);
    rsiHandle = iRSI(_Symbol, PERIOD_CURRENT, RSI_Period, PRICE_CLOSE);
    if(bbHandle == INVALID_HANDLE || rsiHandle == INVALID_HANDLE)
        return(INIT_FAILED);
    return(INIT_SUCCEEDED);
}

void OnTick()
{
    double bbUpper[], bbLower[], bbMiddle[], rsi[];
    ArraySetAsSeries(bbUpper, true);
    ArraySetAsSeries(bbLower, true);
    ArraySetAsSeries(bbMiddle, true);
    ArraySetAsSeries(rsi, true);

    CopyBuffer(bbHandle, 0, 0, 3, bbMiddle);  // Middle band
    CopyBuffer(bbHandle, 1, 0, 3, bbUpper);   // Upper band
    CopyBuffer(bbHandle, 2, 0, 3, bbLower);   // Lower band
    CopyBuffer(rsiHandle, 0, 0, 3, rsi);

    double close1 = iClose(_Symbol, PERIOD_CURRENT, 1);
    bool hasPosition = PositionSelect(_Symbol);

    // Buy at lower band with RSI confirmation
    if(close1 <= bbLower[1] && rsi[1] < 30 && !hasPosition)
    {
        double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
        double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
        double sl = ask - StopLossPips * point * 10;
        trade.Buy(LotSize, _Symbol, ask, sl, 0, "BB Bounce Buy");
    }

    // Exit at middle band
    if(close1 >= bbMiddle[1] && hasPosition)
    {
        trade.PositionClose(_Symbol);
    }
}

void OnDeinit(const int reason)
{
    IndicatorRelease(bbHandle);
    IndicatorRelease(rsiHandle);
}

import pandas as pd
import numpy as np

def calculate_bollinger_bands(prices, period=20, std_mult=2):
    """Calculate Bollinger Bands"""
    middle = prices.rolling(window=period).mean()
    std = prices.rolling(window=period).std()
    upper = middle + (std_mult * std)
    lower = middle - (std_mult * std)
    return upper, middle, lower

def bb_bounce_strategy(df, bb_period=20, std_mult=2, rsi_period=14):
    """Bollinger Bounce with RSI Confirmation"""
    df = df.copy()
    df['bb_upper'], df['bb_middle'], df['bb_lower'] = calculate_bollinger_bands(
        df['close'], bb_period, std_mult
    )

    # RSI
    delta = df['close'].diff()
    gain = delta.where(delta > 0, 0).rolling(window=rsi_period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=rsi_period).mean()
    rs = gain / loss
    df['rsi'] = 100 - (100 / (1 + rs))

    # Signals
    df['signal'] = 0
    df.loc[(df['close'] <= df['bb_lower']) & (df['rsi'] < 30), 'signal'] = 1
    df.loc[df['close'] >= df['bb_middle'], 'signal'] = -1

    df['position'] = df['signal'].replace(0, np.nan).ffill().fillna(0)
    return df

//@version=5
strategy("BB Squeeze Strategy", overlay=true)

// Bollinger Bands
bbLength = input(20, "BB Length")
bbMult = input.float(2.0, "BB Multiplier")
basis = ta.sma(close, bbLength)
bbDev = bbMult * ta.stdev(close, bbLength)
bbUpper = basis + bbDev
bbLower = basis - bbDev

// Keltner Channel (for squeeze detection)
kcLength = input(20, "KC Length")
kcMult = input.float(1.5, "KC Multiplier")
kcBasis = ta.ema(close, kcLength)
kcRange = kcMult * ta.atr(kcLength)
kcUpper = kcBasis + kcRange
kcLower = kcBasis - kcRange

// Squeeze: BB inside KC
squeeze = bbLower > kcLower and bbUpper < kcUpper
noSqueeze = not squeeze

// Momentum
momentum = ta.linreg(close - basis, bbLength, 0)

// Entry: Squeeze fires with positive momentum
if (noSqueeze and squeeze[1] and momentum > 0)
    strategy.entry("Long", strategy.long)

if (noSqueeze and squeeze[1] and momentum < 0)
    strategy.entry("Short", strategy.short)

// Exit on opposite signal
if (strategy.position_size > 0 and momentum < 0)
    strategy.close("Long")
if (strategy.position_size < 0 and momentum > 0)
    strategy.close("Short")

//@version=5
strategy("BB Band Walk", overlay=true)

length = input(20, "BB Length")
mult = input.float(2.0, "BB Multiplier")

basis = ta.sma(close, length)
dev = mult * ta.stdev(close, length)
upper = basis + dev
lower = basis - dev

// ADX for trend strength
adxValue = ta.adx(high, low, close, 14)
strongTrend = adxValue > 25

// Band walk: consecutive closes above upper band in strong trend
walkUp = close > upper and close[1] > upper[1] and strongTrend
walkDown = close < lower and close[1] < lower[1] and strongTrend

if (walkUp)
    strategy.entry("Long", strategy.long)

if (close < basis or walkDown)
    strategy.close("Long")