← Back to Home
OBV Momentum Strategy - Volume-Confirmed Trend Following with RSI and Trailing Stops

OBV Momentum Strategy - Volume-Confirmed Trend Following with RSI and Trailing Stops

Volume is a critical component of technical analysis, often confirming the strength and validity of price movements. The On-Balance Volume (OBV) indicator, developed by Joe Granville, integrates price and volume to measure buying and selling pressure. When OBV rises, it suggests accumulation; when it falls, distribution. This article introduces the OBVMomentumRSIVolumeConfirmationStrategy, a trend-following system that generates signals from OBV and its moving average, further confirmed by Relative Strength Index (RSI) and volume, while always employing adaptive trailing stops for disciplined exits.

Pasted image 20250730020641.png

The Strategy’s Core Components

The strategy is implemented using backtrader, featuring a custom OBV indicator and a strategy class that combines it with filtering mechanisms.

import backtrader as bt

# Custom On-Balance Volume Indicator
class CustomOBV(bt.Indicator):
    lines = ('obv',)
    plotinfo = dict(subplot=True) # Plot OBV on its own subplot
    
    def next(self):
        # Handle the very first bar initialization or subsequent bars
        if len(self) == 1:
            # For the first bar relative to the previous day's close (hypothetical, or assume 0 initial value)
            # In Backtrader, `len(self)` starts from 1, so `self.data.close[-1]` means previous close.
            # However, for the very first bar in the dataset, there is no previous data.
            # A common practice is to initialize OBV with the first bar's volume or 0.
            # The provided code implicitly handles this by comparing to [-1] which might be invalid.
            # A more robust initial setup for the very first bar would be:
            if self.data.close[0] > self.data.close[-1]: # This means current close is higher than previous
                self.lines.obv[0] = self.data.volume[0]
            elif self.data.close[0] < self.data.close[-1]:
                self.lines.obv[0] = -self.data.volume[0]
            else:
                self.lines.obv[0] = 0 # No change in close price
        else:
            prev_obv = self.lines.obv[-1] # Get previous OBV value
            if self.data.close[0] > self.data.close[-1]: # Closing price increased
                self.lines.obv[0] = prev_obv + self.data.volume[0]
            elif self.data.close[0] < self.data.close[-1]: # Closing price decreased
                self.lines.obv[0] = prev_obv - self.data.volume[0]
            else: # Closing price unchanged
                self.lines.obv[0] = prev_obv


class OBVMomentumRSIVolumeConfirmationStrategy(bt.Strategy):
    params = (
        ('obv_ma_period', 30),      # Period for OBV's moving average
        ('trail_percent', 0.02),    # Percentage for trailing stop
        ('rsi_period', 14),         # Period for RSI confirmation
        ('volume_ma_period', 7),    # Period for average volume confirmation
    )
    
    def __init__(self):
        self.order = None # To track active orders and avoid duplicate entries
        
        # --- Indicators ---
        self.obv = CustomOBV(self.datas[0]) # Custom OBV indicator
        self.obv_ma = bt.indicators.SimpleMovingAverage(
            self.obv.lines.obv, period=self.params.obv_ma_period
        )
        self.obv_cross = bt.indicators.CrossOver(self.obv.lines.obv, self.obv_ma) # OBV crossover signal
        
        # --- Filter Indicators ---
        self.rsi = bt.indicators.RSI(period=self.params.rsi_period)
        self.volume_ma = bt.indicators.SMA(self.data.volume, period=self.params.volume_ma_period)

  1. On-Balance Volume (OBV) and its Moving Average: The custom CustomOBV indicator calculates OBV. A SimpleMovingAverage of this OBV line (obv_ma) is then used to identify momentum shifts. A bullish signal is generated when OBV crosses above its MA, indicating increasing buying pressure, while a bearish signal occurs when OBV crosses below its MA.

  2. RSI (Relative Strength Index) as a Momentum Filter: To avoid overextended moves and potential reversals, RSI is used. For long entries, the RSI must be below 70 (not overbought). For short entries, it must be above 30 (not oversold). This helps ensure entries are made in a healthier momentum range.

  3. Volume Confirmation: Price movements are more reliable when confirmed by significant volume. The strategy requires the current bar’s volume to be greater than its average volume over a volume_ma_period. This adds an extra layer of validation to the OBV signals.

  4. Adaptive Trailing Stops for Exit Management: As per the system’s robust risk management, all positions are exited using a trailing stop. This allows profits to accumulate during sustained trends while simultaneously protecting against sudden reversals by dynamically adjusting the stop level.

    def notify_order(self, order):
    if order.status in [order.Submitted, order.Accepted]:
        return
    if order.status in [order.Completed]:
        if order.isbuy():
            # On buy order completion, place a trailing sell stop
            self.sell(exectype=bt.Order.StopTrail, trailpercent=self.params.trail_percent)
        elif order.issell():
            # On sell order completion, place a trailing buy stop
            self.buy(exectype=bt.Order.StopTrail, trailpercent=self.params.trail_percent)
    self.order = None # Clear order reference after completion/cancellation

Execution Logic

The next method, executed on each new bar, contains the core trading logic:

    def next(self):
        if self.order: # If an order is pending, do not issue new ones
            return
            
        if not self.position: # Check for entry signals if no position is open
            # Long signal: OBV crosses up AND RSI not overbought AND current volume is strong
            if (self.obv_cross[0] > 0.0 and 
                self.rsi[0] < 70 and 
                self.data.volume[0] > self.volume_ma[0]):
                self.order = self.buy()
                
            # Short signal: OBV crosses down AND RSI not oversold AND current volume is strong
            elif (self.obv_cross[0] < 0.0 and 
                  self.rsi[0] > 30 and 
                  self.data.volume[0] > self.volume_ma[0]):
                self.order = self.sell()
        # No explicit exit conditions beyond the trailing stop are defined in 'next'.
        # The trailing stop placed in 'notify_order' handles all position closures.

When OBV crosses its moving average, the strategy checks for confirmation from RSI and volume. If conditions are met, a buy or sell order is placed. Once an entry is confirmed and executed, a trailing stop (with trailpercent of 0.02, or 2%) is automatically set to manage the trade’s exit. This setup aims to ride trends while dynamically protecting profits.

1. Parameter Optimization: Finding the Best Fit

Parameter optimization systematically tests various combinations of a strategy’s input parameters to find those that yield the best historical performance according to a chosen metric (e.g., Sharpe Ratio, total return). This process helps in identifying the most effective settings for a given strategy on a specific dataset.

import backtrader as bt
import numpy as np
import pandas as pd
import yfinance as yf # Assuming yfinance is used for data fetching

def optimize_parameters(strategy_class, opt_params, ticker, start_date, end_date):
    """Run optimization to find best parameters with diagnostics"""
    print("="*60)
    print(f"OPTIMIZING: {strategy_class.__name__} on {ticker}")
    print("="*60)

    # Fetch data for optimization
    print(f"Fetching data from {start_date} to {end_date}...")
    # User-specified: yfinance download with auto_adjust=False and droplevel(axis=1, level=1)
    df = yf.download(ticker, start=start_date, end=end_date, auto_adjust=False, progress=False)
    if isinstance(df.columns, pd.MultiIndex):
        df = df.droplevel(1, axis=1)

    if df.empty:
        print("No data fetched for optimization. Exiting.")
        return None

    print(f"Data shape: {df.shape}")
    print(f"Date range: {df.index[0].date()} to {df.index[-1].date()}")

    # Set up optimization
    cerebro = bt.Cerebro()
    data = bt.feeds.PandasData(dataname=df)
    cerebro.adddata(data)
    
    start_cash = 10000.0
    cerebro.broker.setcash(start_cash)
    cerebro.broker.setcommission(commission=0.001)
    
    # Add analyzers for performance metrics
    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe', timeframe=bt.TimeFrame.Days, annualize=True, riskfreerate=0.0)
    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')

    print("Testing parameter combinations...")
    cerebro.optstrategy(strategy_class, **opt_params) # Run the optimization

    stratruns = cerebro.run()
    print(f"Optimization complete! Tested {len(stratruns)} combinations.")

    # Collect and analyze results
    results = []
    for i, run in enumerate(stratruns):
        strategy = run[0]
        sharpe_analysis = strategy.analyzers.sharpe.get_analysis()
        returns_analysis = strategy.analyzers.returns.get_analysis()
        trades_analysis = strategy.analyzers.trades.get_analysis()
        
        rtot = returns_analysis.get('rtot', 0.0)
        final_value = start_cash * (1 + rtot)
        sharpe_ratio = sharpe_analysis.get('sharperatio', -999.0) # Default to a low number
        total_trades = trades_analysis.get('total', {}).get('total', 0)

        if sharpe_ratio is None or np.isnan(sharpe_ratio):
            sharpe_ratio = -999.0

        result = {
            'sharpe_ratio': sharpe_ratio,
            'final_value': final_value,
            'return_pct': rtot * 100,
            'total_trades': total_trades,
        }
        
        # Dynamically add parameter values to the results
        param_values = {p: getattr(strategy.p, p) for p in opt_params.keys()}
        result.update(param_values)
        
        results.append(result)

    # Filter for valid results (at least one trade) and sort
    valid_results = [r for r in results if r['total_trades'] > 0]
    
    if not valid_results:
        print("\nNo combinations resulted in any trades. Cannot determine best parameters.")
        return None
        
    results_sorted = sorted(valid_results, key=lambda x: x['sharpe_ratio'], reverse=True)
    
    print(f"\n{'='*120}")
    print("TOP 5 PARAMETER COMBINATIONS BY SHARPE RATIO")
    print(f"{'='*120}")
    
    top_5_df = pd.DataFrame(results_sorted[:5])
    print(top_5_df.to_string())
    
    best_params = results_sorted[0]
    print(f"\nBest Parameters Found: {best_params}")
    
    return best_params

Key Features of optimize_parameters:

2. Generalized Rolling Backtesting: Assessing Out-of-Sample Performance

Once optimal parameters are identified from an in-sample optimization period, a rolling backtest (also known as walk-forward optimization) assesses the strategy’s stability and performance on unseen data. This method simulates how a strategy would perform in live trading by iteratively optimizing on one period and testing on a subsequent, out-of-sample period.

import dateutil.relativedelta as rd # Needed for date calculations in rolling backtest

def run_rolling_backtest(strategy_class, strategy_params, ticker, start, end, window_months):
    """Generalized rolling backtest function"""
    all_results = []
    start_dt = pd.to_datetime(start)
    end_dt = pd.to_datetime(end)
    current_start = start_dt
    
    while True:
        current_end = current_start + rd.relativedelta(months=window_months)
        if current_end > end_dt:
            break
            
        print(f"\nROLLING BACKTEST: {current_start.date()} to {current_end.date()}")
        
        # Fetch data for the current window
        # User-specified: yfinance download with auto_adjust=False and droplevel(axis=1, level=1)
        data = yf.download(ticker, start=current_start, end=current_end, auto_adjust=False, progress=False)
        
        if data.empty or len(data) < 30: # Need at least some data for indicators to warm up
            print("Not enough data for this period. Skipping window.")
            current_start += rd.relativedelta(months=window_months)
            continue
            
        if isinstance(data.columns, pd.MultiIndex):
            data = data.droplevel(1, 1)
        
        # Calculate Buy & Hold return for the period as a benchmark
        start_price = data['Close'].iloc[0]
        end_price = data['Close'].iloc[-1]
        benchmark_ret = (end_price - start_price) / start_price * 100
        
        # Setup and run Cerebro for the current window
        feed = bt.feeds.PandasData(dataname=data)
        cerebro = bt.Cerebro()
        
        cerebro.addstrategy(strategy_class, **strategy_params) # Use the optimized parameters
        cerebro.adddata(feed)
        cerebro.broker.setcash(100000) # Initial cash for the window
        cerebro.broker.setcommission(commission=0.001)
        cerebro.addsizer(bt.sizers.PercentSizer, percents=95) # Allocate 95% of capital per trade
        cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')
        
        start_val = cerebro.broker.getvalue()
        results_run = cerebro.run()
        final_val = cerebro.broker.getvalue()
        strategy_ret = (final_val - start_val) / start_val * 100
        
        # Get trade statistics
        trades_analysis = results_run[0].analyzers.trades.get_analysis()
        total_trades = trades_analysis.get('total', {}).get('total', 0)
        
        all_results.append({
            'start': current_start.date(),
            'end': current_end.date(),
            'return_pct': strategy_ret,
            'benchmark_pct': benchmark_ret,
            'trades': total_trades,
        })
        
        print(f"Strategy Return: {strategy_ret:.2f}% | Buy & Hold Return: {benchmark_ret:.2f}% | Trades: {total_trades}")
        current_start = current_end # Move to the next window
        
    return pd.DataFrame(all_results)

Key Features of run_rolling_backtest:

Conclusion

The OBVMomentumRSIVolumeConfirmationStrategy provides a robust framework for systematic trend following. By combining the volume-price relationship captured by OBV with momentum and volume confirmation filters, and prioritizing dynamic risk management through trailing stops, this strategy offers a compelling approach to disciplined trading in various market conditions.