Forex Backtesting: Spreads, Sessions and Execution Assumptions

The unique microstructure of the foreign exchange marketCopy Anchor Link

Quantitative researchers transitioning from equities or futures to the foreign exchange (FX) market quickly discover that standard backtesting assumptions do not hold. In centralized equity and futures markets, trades execute against a regulated Central Limit Order Book (CLOB)—such as the NYSE, NASDAQ, or CME—where a consolidated tape guarantees a single, auditable National Best Bid and Offer (NBBO) at any timestamp t.

Spot foreign exchange, by contrast, is a decentralized Over-the-Counter (OTC) market. There is no central physical exchange, no single clearinghouse, and no universal tape. Instead, global currency trading operates across a multi-tiered interbank and retail liquidity network.

Interbank Tier:     Tier-1 Money Center Banks (JPMorgan, Deutsche Bank, UBS, Citi)
                                │                      │
Electronic ECNs:      EBS Market (EUR, JPY)     Refinitiv FXall / Currenex (GBP, AUD)
                                │                      │
Wholesale / Prime:    Prime Brokers ──────────> Non-Bank Liquidity Providers (Citadel, XTX)
                                │                      │
Retail Execution:     Retail ECN / STP Brokers ────> Direct Market Making Desks (B-Book)
                                │
Algorithmic Trader:   Individual Python Backtesting Models & Trading Systems

Because of this fragmented structure, historical price feeds are broker-dependent. A 1-hour bar recorded by an institutional ECN like Currenex or EBS will differ by several fractional pips from a retail broker's aggregated feed.

Continuous 24/5 trading cyclesCopy Anchor Link

Forex operates 24 hours a day, five days a week, following the sun across global financial centers. Liquidity and volatility vary substantially depending on which regional desks are open:

The London-New York overlap (12:00 to 16:00 UTC) concentrates peak institutional liquidity, narrow spreads, and high macroeconomic volatility. Conversely, the 21:00 to 23:00 UTC rollover window experiences an acute liquidity vacuum as US desks settle trades while Tokyo and Sydney have yet to achieve critical mass.

Currency pair quotation conventions: Base vs. QuoteCopy Anchor Link

A currency pair is expressed as BASE / QUOTE (e.g., EUR/USD). The quotation defines how many units of the quote currency are required to purchase one unit of the base currency:

\text{Price} = \frac{\text{Quote Currency}}{\text{Base Currency}}

• EUR/USD = 1.0850: 1 Euro costs 1.0850 US Dollars.
• USD/JPY = 155.20: 1 US Dollar costs 155.20 Japanese Yen.

In standard 4-decimal currency pairs, the minimum conventional unit of price fluctuation is a pip (Percentage in Point), defined as 0.0001. A fractional pip, or pipette, is the 5th decimal place (0.00001). For Japanese Yen crosses (quoted to 2 or 3 decimals), 1 pip equals 0.01, and 1 pipette equals 0.001.

Key challenges in FX backtestingCopy Anchor Link

Naive historical backtests that treat currency pairs like continuous equity series invariably fail in out-of-sample forward trading. Four distinct structural realities must be modeled.

1. Bid/Ask spread dynamics: Asian sessions and the 5 PM EST rollover spikeCopy Anchor Link

In equity backtests, researchers often assume a negligible static transaction fee. In spot forex, the bid/ask spread is your primary cost of trading, and it is highly non-stationary.

At 5:00 PM Eastern Standard Time (21:00 or 22:00 UTC depending on Daylight Saving Time), New York trading desks officially close and end-of-day banking books settle. During this 60- to 120-minute window, interbank tier-1 market makers pull pricing algorithms to recalibrate risk.

EUR/USD Spread Over 24 Hours:

Spread (pips)
  12 ┤                                        ╭─╮ (5 PM EST Rollover Spike)
  10 ┤                                        │ │
   8 ┤                                        │ │
   6 ┤                                        │ │
   4 ┤                 ╭─╮ (Asian Lull)       │ │
   2 ┤      ╭──────────╯ ╰───────────╮        │ │
   0 ┴──────┴────────────────────────┴────────┴─┴──────────> Time (UTC)
           08:00 (London)          16:00 (NY) 21:00

Spreads on EUR/USD that average 0.8 pips during the London session frequently widen to 5.0 to 12.0 pips during rollover. Minor pairs (e.g., EUR/NZD, GBP/CAD) can expand to 25 to 50 pips. A strategy that places tight trailing stops or enters orders across the 5 PM EST boundary using mid-prices will trigger disastrous stop-outs in live production that never appeared in the backtest.

2. Weekend gap risk: Friday close to Sunday openCopy Anchor Link

Spot forex markets close Friday at 5:00 PM EST (21:00 UTC) and reopen Sunday at 5:00 PM EST (21:00 UTC) in Wellington and Sydney. During this 48-hour closure, geopolitical events, election results, emergency central bank statements, and conflict escalations continue uninterrupted.

When the market reopens on Sunday, the opening price frequently jumps dozens or even hundreds of pips away from Friday's close:

Friday 20:59 UTC:  Market Closes at 1.0850 (Stop-Loss set at 1.0820)
──────────────────────────────────────────────────────────────────────
48-Hour Weekend:   Geopolitical crisis or macro policy announcement
──────────────────────────────────────────────────────────────────────
Sunday 21:01 UTC:  Market Gaps Open at 1.0740  (80 pips below Stop-Loss!)

[!WARNING] If your backtesting engine assumes that stop-loss orders are guaranteed fills at the exact order price, your backtest will exhibit severe survivorship bias. In live trading, a stop placed at 1.0820 fills at the first available market price—here, 1.0740—incurring an additional 80 pips of slippage.

3. Rollover / Swap financing: Interest rate differentialsCopy Anchor Link

Spot FX contracts settle on a T+2 rolling basis. Holding an open position across 5:00 PM EST triggers a "Tom-Next" (Tomorrow-Next) rollover swap. The broker closes the open position and reopens it for the next settlement date, charging or crediting an interest rate differential based on the central bank benchmark rates of the two currencies, minus retail financing markups:

\text{Swap Rate} \approx r_{\text{Base}} - r_{\text{Quote}} - \text{Broker Markup}

• Positive Carry: Long a currency with a higher central bank rate against a currency with a lower rate (e.g., Long USD vs Short JPY during wide rate divergence).
• Negative Carry: Short a higher-yielding currency against a lower-yielding currency.
• Wednesday Triple Swap: Because weekend settlements skip Saturday and Sunday, trades held over Wednesday night (settling Friday to Monday) incur three days of swap charges in a single overnight rollover.

For medium-term swing and trend-following systems holding positions for weeks, accumulated negative swap can degrade annualized equity returns by 2% to 6%.

4. Leverage, margin maintenance, and pip point valuationCopy Anchor Link

Forex accounts operate on margin leverage. Sizing must be evaluated using notional contract lots rather than raw share counts:

• Standard Lot: 100,000 units of the base currency.
• Mini Lot: 10,000 units of the base currency.
• Micro Lot: 1,000 units of the base currency.

Pip valuation depends directly on the quote currency:

Under ESMA regulations (EU/UK), retail leverage is capped at 30:1 (3.33% margin requirement) on major pairs. Under US CFTC regulations, retail leverage is capped at 50:1 (2.0% margin). Backtests must enforce these leverage constraints to prevent testing strategies that would suffer immediate broker margin liquidation.

Modeling forex in Python: Working with OHLC dataCopy Anchor Link

Most quantitative traders begin researching FX strategies using historical OHLC bars sourced from retail feeds, brokers, or historical data aggregators. Understanding how these bars are synthesized is essential for realistic backtesting.

The limitations of mid-price OHLCCopy Anchor Link

The vast majority of downloadable historical OHLC bars are mid-price bars:

\text{Mid Price} = \frac{\text{Bid} + \text{Ask}}{2}

If your backtesting engine matches a buy order on the Open or Close of a mid-price bar, the simulation enters at the mid-price. In the live market, however, market orders buy at the Ask and sell at the Bid:

\text{Ask} = \text{Mid} + \frac{\text{Spread}}{2}, \quad \text{Bid} = \text{Mid} - \frac{\text{Spread}}{2}

Mid-Price Bar Trap:
Engine Buys at:    1.08500 (Mid)  ───> Fake execution inside the spread
Physical Reality:  1.08508 (Ask)  ───> Real market buy price (+0.8 pips adverse)

For an intraday swing system targeting 15 pips per trade, ignoring a 1.2-pip round-trip spread overstates strategy gross alpha by 8% to 12% on every single trade. Over hundreds of trades, a seemingly profitable strategy collapses into a steady loser.

Approximating bid/ask spreads via explicit slippage offsetsCopy Anchor Link

When full tick-level bid/ask order book feeds are unavailable, you can approximate bid/ask friction in OpenBacktesting using deterministic cost models:

1. Fixed Pip Slippage: Configure Slippage("fixed", 0.00015) on the Backtest engine. On EUR/USD, this automatically penalizes every execution by 1.5 pips (0.00015), accounting for the half-spread plus execution latency.
2. Proportional Commission: ECN brokers charge a fixed commission per round turn (typically $2.50 to $3.50 per 100,000 units, which equates to ~0.3 basis points).
3. Session-Conditional Filters: In your strategy's next() callback, inspect the bar's UTC timestamp to restrict trading to liquid market hours and enforce a strict blackout during the 21:00 to 23:00 UTC rollover window.

Complete runnable Python exampleCopy Anchor Link

The following self-contained Python script demonstrates a realistic single-asset forex backtest using OpenBacktesting (v0.2.1).

It constructs an hourly EUR/USD historical series with realistic session volatility patterns and weekend gap jumps, implements a London Breakout Strategy that tracks Asian consolidation, applies a rollover blackout filter, sizes in mini lots (10,000 units), and incorporates explicit 1.5-pip execution slippage and ECN broker commission.

"""Forex Session Breakout Backtest with Spread & Rollover Assumptions.

Framework: OpenBacktesting (v0.2.1)
Pair: EUR/USD (Hourly OHLCV)
"""

from __future__ import annotations

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


def generate_eurusd_hourly_dataset() -> pd.DataFrame:
    """Synthesize realistic hourly EUR/USD data covering global sessions.
    
    Includes:
    - 24/5 continuous trading excluding weekend closures.
    - Session-specific intraday volatility (London/NY peak vs Asian consolidation).
    - Discontinuous Sunday open gaps simulating weekend headline risk.
    """
    # 90 calendar days of hourly timestamps
    raw_dates = pd.date_range("2026-03-01 00:00", "2026-05-30 21:00", freq="1h", tz="UTC")
    
    # Filter standard FX weekend closures (Friday 22:00 UTC to Sunday 21:00 UTC)
    trading_dates = [
        d for d in raw_dates
        if not (
            d.weekday() == 5  # Saturday: fully closed
            or (d.weekday() == 6 and d.hour < 21)  # Sunday: closed until 21:00 UTC
            or (d.weekday() == 4 and d.hour >= 22)  # Friday: closes at 22:00 UTC
        )
    ]
    dates = pd.DatetimeIndex(trading_dates)
    n = len(dates)

    np.random.seed(42)
    hours = dates.hour
    
    # Hourly volatility scaling: London (08-16 UTC) & NY overlap are most active
    vol_multiplier = np.where((hours >= 8) & (hours <= 16), 1.5, 0.7)
    base_returns = np.random.normal(0, 0.0006, n) * vol_multiplier
    
    close = 1.0850 * np.exp(np.cumsum(base_returns))
    high = close * (1 + np.abs(np.random.normal(0, 0.00035, n)))
    low = close * (1 - np.abs(np.random.normal(0, 0.00035, n)))
    open_ = np.roll(close, 1)
    open_[0] = close[0]

    # Inject discrete weekend price gaps on Sunday 21:00 UTC reopen bars
    for i in range(1, n):
        time_delta = (dates[i] - dates[i - 1]).total_seconds()
        if time_delta > 3600 * 24:  # Gap crossing Friday to Sunday
            weekend_gap = np.random.normal(0, 0.0020)  # ~20 pip weekend jump
            open_[i] = close[i - 1] + weekend_gap
            close[i] = open_[i] + np.random.normal(0, 0.0006)
            high[i] = max(open_[i], close[i]) + 0.0004
            low[i] = min(open_[i], close[i]) - 0.0004

    return pd.DataFrame(
        {
            "Open": open_,
            "High": np.maximum.reduce([open_, high, close]),
            "Low": np.minimum.reduce([open_, low, close]),
            "Close": close,
            "Volume": np.random.randint(800, 6000, n),
        },
        index=dates,
    )


class LondonBreakoutForexStrategy(Strategy):
    """Forex session momentum strategy trading the London opening expansion.
    
    Rules:
    1. Tracks high/low bounds during Asian session consolidation (00:00 to 07:00 UTC).
    2. Enters breakout orders during London morning session (08:00 to 12:00 UTC).
    3. Sizes positions in 1 mini lot (10,000 EUR base currency units).
    4. Attaches explicit Stop-Loss (25 pips) and Take-Profit (50 pips).
    5. Liquidates intraday positions at 18:00 UTC to avoid 5 PM EST rollover spreads.
    6. Strictly blackouts trading during rollover hours (21:00 to 23:00 UTC).
    """

    atr_period = 14
    sl_pips = 25
    tp_pips = 50
    mini_lot = 10_000  # 10,000 units of base currency (EUR)

    def init(self):
        """Vectorized indicator precomputation."""
        # Built-in ta.atr automatically consumes self.high, self.low, self.close
        self.atr = self.ta.atr(length=self.atr_period)
        self.asian_high = 0.0
        self.asian_low = float("inf")

    def next(self):
        """Bar-by-bar causal trade logic."""
        if not self.atr.valid[-1]:
            return

        current_time = self.data.index[-1]
        hour = current_time.hour
        pip = self.pip  # Native OpenBacktesting decimal precision (0.0001 for EUR/USD)

        # 1. Rollover blackout: avoid trading in the 21:00-23:00 UTC spread widening window
        if 21 <= hour <= 23:
            return

        # 2. Asian session tracking (00:00 to 07:00 UTC)
        if hour == 0:
            self.asian_high = self.high[-1]
            self.asian_low = self.low[-1]
        elif 1 <= hour <= 7:
            self.asian_high = max(self.asian_high, self.high[-1])
            self.asian_low = min(self.asian_low, self.low[-1])

        # 3. Execution window: London open through midday (08:00 to 12:00 UTC)
        if not self.position:
            if 8 <= hour <= 12 and self.asian_high > 0:
                # Long breakout above Asian consolidation ceiling
                if self.close[-1] > self.asian_high:
                    sl = self.close[-1] - (self.sl_pips * pip)
                    tp = self.close[-1] + (self.tp_pips * pip)
                    self.buy(qty=self.mini_lot, sl=sl, tp=tp)

                # Short breakdown below Asian consolidation floor
                elif self.close[-1] < self.asian_low:
                    sl = self.close[-1] + (self.sl_pips * pip)
                    tp = self.close[-1] - (self.tp_pips * pip)
                    self.sell(qty=self.mini_lot, sl=sl, tp=tp)
        else:
            # 4. Mandatory intraday session exit prior to New York close
            if hour >= 18:
                self.position.close()


def run_forex_audit():
    """Configure and execute the forex simulation with realistic parameters."""
    df = generate_eurusd_hourly_dataset()
    print(f"Loaded {len(df)} EUR/USD bars ({df.index[0]} to {df.index[-1]})")

    # Configure Backtest engine with institutional execution assumptions
    bt = Backtest(
        data=df,
        strategy=LondonBreakoutForexStrategy,
        cash=10_000.0,                      # $10,000 initial equity
        margin=1 / 30,                       # 30:1 regulatory leverage (3.33% margin)
        commission=0.00003,                  # 0.3 bps ECN broker fee (~$3 per 100k notional)
        slippage=Slippage("fixed", 0.00015), # 1.5 pips fixed bid/ask spread & execution slippage
        execution_timing="next_open",       # Orders fill causally at next-bar open
        end_policy="close_at_last_close",   # Liquidate lingering inventory on final bar
    )

    stats = bt.run()

    # Print summary performance metrics
    print("\n" + "=" * 60)
    print("FOREX STRATEGY BACKTEST RESULTS")
    print("=" * 60)

    report_metrics = [
        "Start",
        "End",
        "Duration",
        "Return [%]",
        "Sharpe Ratio",
        "Sortino Ratio",
        "Max. Drawdown [%]",
        "# Trades",
        "Win Rate [%]",
        "Profit Factor",
    ]

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

    # Inspect first few trades from the trade execution ledger
    trades = stats._trades
    print("\n" + "=" * 60)
    print(f"TRADE EXECUTION AUDIT (Total Trades: {len(trades)})")
    print("=" * 60)
    if not trades.empty:
        cols = ["EntryTime", "ExitTime", "Size", "EntryPrice", "ExitPrice", "PnL", "ReturnPct"]
        available_cols = [c for c in cols if c in trades.columns]
        print(trades[available_cols].head(5).to_string(index=False))

    # Export immutable Portfolio report schema for reproducible audit trails
    report = export_result(stats)
    print("\n" + "=" * 60)
    print(f"Audit Report exported successfully. Schema Version: {report.get('schemaVersion', 'v1')}")
    print("=" * 60)


if __name__ == "__main__":
    run_forex_audit()

Explanation of execution mechanicsCopy Anchor Link

1. Native Pip Detection (self.pip): OpenBacktesting automatically inspects the decimal granularity of your dataset. For standard 4-decimal currency data, self.pip resolves to 0.0001, eliminating hardcoded scaling errors.
2. Deterministic Bracket Stops (sl and tp): The buy() and sell() methods accept explicit sl and tp target levels. In bar-by-bar simulation, the broker engine tracks order state and executes exits upon price breach.
3. Causal Next-Open Fills (execution_timing="next_open"): When a breakout condition is detected at the close of bar t, the order is matched at the opening price of bar t+1. This strictly prevents lookahead bias and simulates real-world order queuing.
4. Leverage Calibration (margin=1/30): Setting margin=1/30 models a 30:1 regulatory leverage environment, ensuring margin reservation and portfolio equity checks remain realistic.

Realistic boundary setting: What standard OHLC backtests can and cannot proveCopy Anchor Link

Understanding the methodological boundary of your backtesting software is essential for avoiding costly live-trading errors.

What single-asset OHLC engines prove with mathematical precisionCopy Anchor Link

OpenBacktesting is an open-source Python framework engineered for single-asset historical OHLCV bar-by-bar backtesting. Within this defined domain, it deterministically guarantees:

• Strict Temporal Causality: Indicator warm-up periods are verified via .valid checks, and signals generated at bar t fill at bar t+1 without retrospective leakage.
• Explicit Friction Accounting: Constant or basis-point slippage schedules and broker commission schedules are subtracted from the cash ledger on every fill.
• Deterministic Order Matching: Standard order primitives (market, limit, stop, stop-limit, trailing stop, and OCO) are matched against historical bar boundaries.
• Reproducible Audit Trails: Results can be exported into immutable Portfolio reports or inspected interactively via the local browser-based OpenBacktesting Studio.

What standard OHLC backtests cannot prove (Institutional FX realities)Copy Anchor Link

While single-asset OHLC simulations provide a rigorous first-stage filter for quantitative hypotheses, currency markets possess microstructure dynamics that require explicit awareness:

1. Intra-Bar Tick Ambiguity: On an hourly or daily bar, the engine knows the Open, High, Low, and Close, but it does not know the exact path price took inside the bar. If a strategy's Stop-Loss and Take-Profit are both situated within the High-Low range of that single bar, standard OHLC backtests cannot prove whether the stop or target was hit first without tick-level order book records.
2. Flash Spread Blowouts: High-impact macroeconomic releases—such as US Non-Farm Payrolls (NFP) or central bank interest rate decisions—can cause market-maker order books to evaporate for several seconds. Spreads can instantly jump to 20 or 30 pips. An hourly bar averages this event into an extended wick, concealing the execution slippage that a live market order would experience.
3. Dynamic Swap Rate Curves: In live trading, overnight rollover rates fluctuate daily based on interbank repo markets and broker financing tiering. A backtest relying on a fixed interest estimate cannot replicate dynamic multi-month carry yield curves.
4. Multi-Currency Cross-Hedging: Spot FX portfolios frequently hold multiple correlated pairs simultaneously (e.g., long EUR/USD while short GBP/USD and long USD/JPY). OpenBacktesting models single-asset time series; it does not serve as a native multi-asset portfolio accounting engine or a native futures daily settlement engine.

[!NOTE] OpenBacktesting focuses exclusively on single-asset historical research and parameter optimization (grid search and SAMBO). It does not provide live-trading broker APIs, real-time data feeds, or low-latency execution routing.

The Forex Backtest Verification ChecklistCopy Anchor Link

Before deploying capital or committing resources to a currency trading model, audit your research pipeline against this 6-point practitioner's checklist:

Conclusion and resourcesCopy Anchor Link

Backtesting currency pairs requires bridging the divide between idealized price charts and the operational reality of decentralized OTC markets. By accounting for variable session liquidity, enforcing a strict rollover blackout, modeling weekend gap execution, and applying realistic spread and commission deductions, you transform theoretical curve fits into durable quantitative strategies.

To continue building your quantitative research framework, explore these foundational guides:

• End-to-End Implementation: Learn how to structure data ingest, write clean strategy callbacks, and inspect trade performance in our Python Backtesting Tutorial: Data, Orders and Results.
• Continuous 24/7 Market Modeling: Compare continuous market microstructure, funding rates, and slippage in our guide on Crypto Backtesting in Python: 24/7 Markets, Funding Rates and Slippage.
• Official Documentation: Review complete engine parameters, position sizing models, and execution configurations in the OpenBacktesting Documentation.