Stock Backtesting in Python: Data Adjustments, Costs and Benchmarks

The unique nuances of equities backtestingCopy Anchor Link

In theoretical quantitative finance, price series are frequently modeled as idealized continuous processes, such as geometric Brownian motion or jump-diffusion paths. In physical equity markets, however, asset prices do not evolve in an unencumbered vacuum. An individual stock represents a fractional ownership interest in a legal corporate entity subject to discrete administrative interventions, exchange market microstructures, and regulatory friction.

When researchers transition from synthetic simulations to historical equities data, backtests frequently fail not because the underlying alpha hypothesis is flawed, but because the simulation engine makes unrealistic assumptions about how stocks trade. Equities present several structural characteristics absent in idealized series:

1. Discrete corporate actions: Stock splits, reverse splits, spin-offs, cash dividends, and rights offerings abruptly alter historical price and share counts.
2. Exchange trading halts: Regulatory Limit Up-Limit Down (LULD) pauses, material news halts (Code T1), and market-wide circuit breakers prevent continuous order matching.
3. Asymmetric transaction friction: Equity transactions incur SEC Section 31 fees, FINRA Trading Activity Fees (TAF), exchange routing fees or rebates, and variable bid-ask spreads.
4. Short sale constraints: Shorting individual stocks requires locating borrowable inventory, paying variable borrow fees (often prohibitive on hard-to-borrow names), and contending with the alternative uptick rule (SEC Rule 201).

Idealized Synthetic Path:    Continuous Float ──────> Instant Execution at Close ───> Zero Friction
                                                                                      
Real Equity Market Reality:  Split Adjustments ────> Halts & Discrete Auctions ────> SEC/FINRA Fees
                             Dividend Ex-Dates ───> Next-Bar Open Matching ────> Bid-Ask Slippage

To produce an empirical backtest that survives out-of-sample live execution, you must model these nuances with absolute determinism. OpenBacktesting is an open-source Python framework designed specifically for single-asset historical OHLCV research, enforcing causal bar-by-bar execution, explicit transaction cost modeling, and reproducible trade ledgers.

Adjusting historical equity data: Splits vs. Cash dividendsCopy Anchor Link

The single most destructive pitfall in equities data ingestion is confusing unadjusted, split-adjusted, and dividend-adjusted price series. Feeding the wrong price series into indicator formulas or order matching engines leads to immediate simulation failure.

Raw (Unadjusted) vs. Split-Adjusted PricesCopy Anchor Link

Raw prices reflect the exact numerical prints recorded on the exchange tape on that date. While raw prices are essential for checking historical option strike availability or regulatory trade-through rules, they cannot be used directly in technical indicators or price-level calculations across corporate action boundaries.

Consider a 4-for-1 forward stock split (such as Apple in August 2020) or a 10-for-1 split (such as Nvidia in June 2024). Before the split, a share trades at $1,200; after the split, each share trades at $120. An investor owning 100 shares at $1,200 now owns 1,000 shares at $120—their net wealth is completely unchanged.

If an unadjusted OHLCV series is fed into a backtesting engine, the mathematical consequences are catastrophic:

Unadjusted Series on 10-for-1 Split:
Day t-1 (Pre-split):  Close = $1,200.00  ───> 20-day SMA = $1,150.00
Day t   (Post-split): Close = $  120.00  ───> Apparent -90.0% market collapse!

Resulting Engine Failures:
1. Trailing stops and stop-loss orders trigger instantaneous forced liquidation.
2. Oscillators (RSI, Stochastics) collapse to zero, generating false "deep oversold" buy signals.
3. Volatility estimators (ATR, Historical Volatility) spike to extreme outlier levels.

To preserve continuity, historical OHLC prices prior to the split must be multiplied by the split adjustment factor f = S_old / S_new = 1 / 10 = 0.1, while historical volume is divided by f (V_adj = V * 10).

Split Discontinuity vs. Split-Adjusted Continuity:

Raw Unadjusted:      $1,200 ─── $1,210 ─── $1,205 ──┐
                                                    └─── $120.50 ─── $122.00  (False -90% drop)

Split-Adjusted:      $  120 ─── $  121 ─── $120.50 ──── $120.50 ─── $122.00  (Smooth, causal)

The Dividend Adjustment DilemmaCopy Anchor Link

While split adjustments preserve true geometric returns and chart geometry, cash dividends introduce a subtle methodological dilemma.

Most retail data feeds (such as Yahoo Finance) provide an Adj Close column that retroactively discounts past prices by the dividend yield:

P_adj(t) = P(t) * Product_{tau > t} [ 1 - (D_tau / P_tau) ]

Where D_tau is the dividend per share paid at ex-dividend date tau, and P_tau is the unadjusted closing price on the eve of the ex-date.

While dividend-adjusted series (often termed Total Return series) correctly measure the compounding return of a buy-and-hold investor who reinvests all cash dividends into additional shares, using dividend-adjusted data creates dangerous side effects in algorithmic backtests:

[!WARNING] If your trading strategy applies absolute dollar rules—such as close > 5.0 (penny stock exclusion) or fixed-dollar stop losses (e.g., StopLoss = entry_price - 1.50)—using dividend-adjusted historical data will severely distort your backtest. A stock that traded at $50 in 2005 may show a dividend-adjusted price of $4.20, causing your logic to misidentify large-cap dividend aristocrats as low-priced penny stocks.

Quant Best Practice: For single-asset stock backtesting, use split-adjusted OHLCV data as the primary pricing input for indicator computation and order execution. Handle cash dividends either via separate balance-sheet cash injections on ex-dividend dates or by evaluating capital gains and dividend yield as distinct components of portfolio return.

Benchmark construction: The buy-and-hold baselineCopy Anchor Link

An equity trading strategy cannot be evaluated in isolation. Generating a +35% total return over a five-year period may appear satisfactory in the abstract, but if the underlying stock gained +140% over the exact same period, your active trading strategy destroyed massive value relative to passive ownership.

The foundational baseline for single-asset stock backtesting is the Buy-and-Hold benchmark. However, calculating an honest buy-and-hold benchmark requires the same rigorous standards applied to the active strategy.

Honest Benchmark Calculation RulesCopy Anchor Link

1. Identical Starting Capital: The benchmark must be funded with the exact same initial cash balance (C_0) as the trading strategy.
2. Causal Entry Timing: The benchmark purchase cannot execute retroactively on the closing price of bar 0. It must execute on the opening price of the first tradable bar (bar 0 or bar 1), matching the causality imposed on strategy orders.
3. Execution Friction: The initial benchmark purchase must incur transaction commission and opening slippage. Assuming frictionless entry on the benchmark while penalizing the strategy creates an unscientific bias.
4. Terminal Accounting Consistency: At the conclusion of the test, the benchmark equity should be evaluated using the same policy as the strategy—either marked to market at the final bar's close or liquidated with closing transaction costs.

Benchmark Capital Progression:
Cash C_0 ───> Pay Commission & Slippage ───> Purchase N Shares at Open_0 ───> Value = N * Close_t

Key Comparative MetricsCopy Anchor Link

Evaluating an equity strategy against its buy-and-hold baseline requires looking beyond total return:

The Power of Market ExposureCopy Anchor Link

A critical advantage of active equity strategies is capital preservation through reduced market exposure.

Suppose a trend-following stock strategy yields a +42% return over a four-year backtest with a maximum drawdown of 12%, while the underlying stock's buy-and-hold baseline yields +48% with a punishing 45% drawdown.

If the active strategy achieved its return with an exposure time of only 38%, its capital efficiency is far superior:

• The strategy was immune to market risk during the remaining 62% of the time.
• The unallocated cash was protected from major drawdowns and could earn risk-free yields or collateralize uncorrelated strategies.
• On an exposure-adjusted basis, the active strategy produced significantly higher alpha per unit of market risk.

Modeling equity transaction frictionsCopy Anchor Link

In liquid equity markets, trading costs extend far beyond the headline commission advertised by retail brokerages. While retail brokers often market "$0 commission" equity trades (funded via Payment for Order Flow), institutional backtesting must account for the physical economic frictions of trade execution.

Breakdown of Equity Transaction CostsCopy Anchor Link

Total Transaction Cost = Broker Commission + Regulatory Fees + Exchange Fees + Bid-Ask Spread / Slippage

1. Brokerage CommissionsCopy Anchor Link

• Fixed Per-Share Pricing: Typical in direct market access (DMA) brokers (e.g., $0.005 per share with a $1.00 minimum ticket fee).
• Proportional Value Pricing: Standard in institutional clearing and asset management (e.g., 5 to 10 basis points, or 0.05% to 0.10% of gross notional trade value).

2. Regulatory Fees (US Equities)Copy Anchor Link

• SEC Section 31 Fee: Mandated by the Securities and Exchange Commission to recover government regulatory costs. Levied exclusively on sell orders (e.g., $0.0000278 per dollar of principal sales value, adjusted periodically).
• FINRA Trading Activity Fee (TAF): Assessed on all equity sell orders to fund FINRA surveillance (e.g., $0.000166 per share sold, capped at $8.30 per trade).

3. Bid-Ask Spread and Market Impact SlippageCopy Anchor Link

When executing a market order or aggressive marketable limit order, you do not fill at the mid-price. You buy at the prevailing Ask and sell at the prevailing Bid:

• For mega-cap equities (e.g., AAPL, MSFT), the bid-ask spread is typically 1 cent ($0.01) during regular hours, equivalent to 0.5 to 1 basis point.
• For small-cap or higher-volatility equities, spreads widen to 5 to 25 basis points or more.
• Market Impact: Large orders consume book depth, pushing the execution price away from the pre-trade quote. If your simulated order represents more than 1% to 2% of the bar's total traded volume, assuming an execution at the bar's open or close without slippage is an exercise in fantasy.

Order Book Liquidity Distribution:
[Ask 3: $150.05 (3,000 shares)] ──┐
[Ask 2: $150.03 (1,500 shares)]   ├── Market Buy for 5,000 shares eats through book!
[Ask 1: $150.01 (1,000 shares)] ──┘   Average Fill Price = $150.034 (2.4 cents slippage)
───────────────────────────────────
[Bid 1: $150.00 (1,200 shares)]
[Bid 2: $149.98 (2,000 shares)]

In OpenBacktesting, execution slippage is configured deterministically using the Slippage module:

• Slippage("bps", 5.0): Degrades execution prices by 5 basis points (0.05%) against the order direction.
• Slippage("fixed", 0.02): Degrades execution prices by $0.02 per share.

Complete Python code example: Backtesting a stock strategyCopy Anchor Link

The following production-ready Python script demonstrates how to backtest a single-stock momentum breakout strategy with dynamic volatility trailing stops using OpenBacktesting v0.2.1.

The strategy utilizes:

• A 20-day breakout rule (entering long when the close crosses above the 20-day high).
• An Average True Range (ATR) volatility trailing stop to protect profits and limit drawdowns.
• Full causal execution timing (execution_timing="next_open").
• Institutional commission (0.05% / 5 bps) and realistic execution slippage (5 bps).
• Direct benchmark comparison against the Buy-and-Hold series.

"""
Single-Asset Stock Backtesting with OpenBacktesting v0.2.1.

Strategy: 20-Day Momentum Breakout with ATR Dynamic Trailing Exit.
Evaluates strategy return against an honest, capital-normalized Buy & Hold benchmark.
"""

import numpy as np
import pandas as pd

from openbacktesting import Backtest, Strategy
from openbacktesting.broker.execution import Slippage
from openbacktesting.portfolio import export_result
from openbacktesting.test import GOOG


class VolatilityBreakoutStockStrategy(Strategy):
    """
    Momentum breakout strategy designed for individual equity trading.
    
    Rules:
    - Precomputes 20-day High/Low channels and a 14-day ATR for volatility tracking.
    - Entry: Buy when price breaks above the 20-day rolling high.
    - Exit: Dynamic trailing stop trailing by 2.5 * ATR below the highest peak price.
    """

    channel_period = 20
    atr_period = 14
    atr_multiplier = 2.5

    def init(self):
        """Vectorized indicator precomputation across historical series."""
        # Rolling 20-day maximum of highs (shifted by 1 to prevent peeking at current high)
        self.channel_high = self.ind(
            lambda h: pd.Series(h).rolling(self.channel_period).max().shift(1).to_numpy(),
            self.high,
        )
        # Average True Range for volatility-based trailing stop
        self.atr = self.ta.atr(self.high, self.low, self.close, length=self.atr_period)
        
        # State tracking for trade-level trailing stop
        self.highest_price = 0.0

    def next(self):
        """Bar-by-bar causal strategy execution."""
        # 1. Warm-up verification: ensure indicators have settled valid numbers
        if len(self.close) < self.channel_period + 2 or not self.atr.valid[-2:].all():
            return

        current_close = self.close[-1]
        current_atr = self.atr[-1]
        breakout_threshold = self.channel_high[-1]

        # 2. Position Management
        if self.position.is_long:
            # Update peak price reached during this holding period
            if current_close > self.highest_price:
                self.highest_price = current_close

            # Compute dynamic trailing stop level
            stop_price = self.highest_price - (self.atr_multiplier * current_atr)

            # Trailing stop breached: exit position on next bar open
            if current_close < stop_price:
                self.position.close()
                self.highest_price = 0.0

        # 3. Entry Signal: Bullish breakout above recent 20-day rolling high
        elif not self.position.is_long:
            if not np.isnan(breakout_threshold) and current_close > breakout_threshold:
                # Allocate 95% of available cash equity, leaving buffer for slippage & fee
                self.buy(percent=95)
                self.highest_price = current_close


def run_stock_audit():
    """Configure, run, and audit the stock backtest."""
    # Ensure data is sorted, unique, and monotonically increasing
    stock_data = GOOG.copy()
    stock_data = stock_data.sort_index()

    print(f"Loaded {len(stock_data)} historical daily bars for {stock_data.index[0].date()} to {stock_data.index[-1].date()}")

    # Initialize Backtest engine with realistic equity execution parameters
    bt = Backtest(
        data=stock_data,
        strategy=VolatilityBreakoutStockStrategy,
        cash=25_000.0,                    # $25,000 capital (standard retail margin baseline)
        commission=0.0005,                # 5 bps broker/regulatory fee model (0.05%)
        slippage=Slippage("bps", 5.0),    # 5 bps execution slippage model
        execution_timing="next_open",     # Causal next-bar open order matching
        end_policy="close_at_last_close", # Liquidate open inventory at final close
    )

    # Execute simulation
    stats = bt.run()

    # Display Comparative Performance Summary
    print("\n" + "=" * 65)
    print("EQUITY STRATEGY VS. BUY & HOLD BENCHMARK SUMMARY")
    print("=" * 65)

    metrics_of_interest = [
        "Start",
        "End",
        "Duration",
        "Return [%]",
        "Buy & Hold Return [%]",
        "Sharpe Ratio",
        "Sortino Ratio",
        "Max. Drawdown [%]",
        "Avg. Drawdown [%]",
        "Exposure Time [%]",
        "# Trades",
        "Win Rate [%]",
        "Profit Factor",
        "Commissions [$]",
    ]

    for metric in metrics_of_interest:
        val = stats.get(metric, "N/A")
        if isinstance(val, float):
            print(f"{metric:<26} : {val:>12.2f}")
        else:
            print(f"{metric:<26} : {str(val):>12}")

    # Inspect trade-level execution log
    trades = stats._trades
    print("\n" + "=" * 65)
    print(f"TRADE LOG AUDIT (Total Closed Trades: {len(trades)})")
    print("=" * 65)

    if not trades.empty:
        summary_cols = ["EntryTime", "ExitTime", "Size", "EntryPrice", "ExitPrice", "PnL", "ReturnPct"]
        available_cols = [c for c in summary_cols if c in trades.columns]
        print(trades[available_cols].head(5).to_string(index=False))

    # Export immutable, standalone Portfolio JSON report for audit trail
    report = export_result(stats)
    print("\n" + "=" * 65)
    print(f"Portfolio Audit Report generated. Schema Version: {report.get('schemaVersion', 'v1')}")
    print("=" * 65)


if __name__ == "__main__":
    run_stock_audit()

Explanation of Key Execution MechanicsCopy Anchor Link

1. Causal Rolling Maximum (shift(1)): In the init() method, channel_high calculates the 20-day maximum of self.high and immediately calls .shift(1). This ensures that when evaluating current_close > breakout_threshold at bar t, the threshold represents the highest high of bars t-20 through t-1, strictly preventing lookahead leakage.
2. Next-Bar Open Execution (execution_timing="next_open"): When a breakout occurs at bar t's close, the order is staged into the engine ledger. The fill occurs on bar t+1's open, adjusting for 5 basis points of slippage and 0.05% commission.
3. Automated Benchmark Normalization: OpenBacktesting automatically constructs the Buy & Hold Return [%] metric from the input dataset, matching starting capital, charging opening transaction friction, and liquidating at the final close to ensure a mathematically fair comparison.

The critical caveat: Survivorship bias in stock researchCopy Anchor Link

When developing algorithmic stock trading strategies, researchers rarely test on only a single stock in isolation. The common workflow involves writing a strategy in Python, downloading historical daily data for all current constituents of the S&P 500 or Nasdaq 100, and running backtests over the past 15 or 20 years.

This workflow is contaminated by survivorship bias—one of the most insidious statistical fallacies in quantitative finance.

The Mechanics of the Survivorship TrapCopy Anchor Link

Today's S&P 500 roster represents the ultimate club of corporate survivors: companies like Apple, Microsoft, Amazon, Alphabet, and Nvidia that grew from modest beginnings to multi-trillion-dollar valuations.

When you backtest against today's constituents from 2005 to 2026:

• You are selecting the winners with 20 years of hindsight.
• You have systematically deleted every company that experienced catastrophic operational failure, bankruptcy, or distressed delisting during that 20-year span.

Historical Reality (2008 Financial Crisis):
Constituent Pool: [ Lehman Brothers, Bear Stearns, Enron, WorldCom, Washington Mutual, Apple, Nvidia ]
                     │              │             │        │            │
                     ▼              ▼             ▼        ▼            ▼
                   Broke          Broke         Broke    Broke        Broke
                  (-100%)        (-100%)       (-100%)  (-100%)      (-100%)

Biased Retrospective Selection (Testing only today's survivors):
Simulated Pool:   [ Apple (+8,500%), Nvidia (+22,000%), Microsoft (+1,400%) ]
Result:           Any momentum or dip-buying strategy shows miraculous, fraudulent profits!

Empirical Distortion of Survivorship BiasCopy Anchor Link

Academic literature and institutional studies demonstrate that survivorship bias artificially inflates backtested equity returns by 1.5% to 4.0% annualized.

In high-beta or small-cap equity universes, the distortion is even more severe:

• Even a completely random entry rule (e.g., flipping a coin to buy) will appear profitable when backtested exclusively on stocks that grew 50-fold over the testing window.
• The backtest never encounters the true reality of equity risk: holding an asset whose price drops by 95% into bankruptcy proceedings or Chapter 11 restructuring where recovery value is zero.

Institutional Solutions for Mitigating BiasCopy Anchor Link

1. Point-in-Time (PIT) Universes: Utilize commercial data vendors (such as CRSP, Compustat, or Norgate Data) that provide point-in-time constituent lists. On any historical date t, your strategy must only trade stocks that were active members of the index on that specific calendar day.
2. Explicit Delisting Return Accounting: When a company is delisted or halted pending bankruptcy, the final liquidation return must be recorded. In many cases, common stock equity is wiped out, resulting in a -100% return on that position.
3. Avoid Universal Survivor Scanning: If using un-curated datasets, validate your strategy across out-of-sample assets that experienced secular bear markets or prolonged stagnation, rather than solely on tech mega-cap winners.

Summary checklist for equities researchCopy Anchor Link

Before accepting any stock backtest as reliable empirical evidence, audit your methodology against this practitioner's checklist:

Continuing Your ResearchCopy Anchor Link

To deepen your understanding of quantitative testing and robust model design, explore these related guides:

• Step-by-Step Backtest Architecture: Walk through building an end-to-end inspectable strategy in our Python Backtesting Tutorial: Data, Orders and Results.
• Preventing Temporal Leakage: Learn how subtle indexing errors ruin predictive signals in What Is Lookahead Bias? Detect Future Data in Python Backtests.
• Official Documentation: Review complete engine parameters, position sizing models, and execution configurations in the OpenBacktesting Documentation.