Python Implementation of Bitcoin Overnight Seasonality Strategy: A Complete Guide

The awesome-systematic-trading repository provides a self-contained Python script at static/strategies/intraday-seasonality-in-bitcoin.py that back-tests the Bitcoin overnight seasonality effect using overnight returns calculated as log(open_today / close_yesterday), supporting long-only, short-only, and long-short configurations.

The paperswithbacktest/awesome-systematic-trading repository offers a curated collection of reproducible systematic trading research written entirely in Python. Each strategy is implemented as an isolated script that handles data acquisition, signal generation, and back-testing without requiring external frameworks or complex infrastructure.

Repository Architecture and Design Philosophy

The repository follows a modular, self-contained design that prioritizes reproducibility and ease of modification. Rather than relying on a monolithic trading framework, each strategy script operates independently, importing only standard scientific libraries such as pandas, numpy, and matplotlib.

The codebase is organized into three primary sections:

• static/strategies/ – Contains over 100 standalone strategy implementations, including the Bitcoin overnight seasonality script
• README.md – Provides installation instructions, data source references, and execution guidelines
• .vscode/ – Houses VS Code configurations for debugging and linting support

Every strategy follows a consistent four-phase pattern:

1. Data Acquisition – Lightweight helper functions pull price data from sources like Yahoo Finance, Binance, or the FRED API
2. Signal Generation – Deterministic rules compute daily exposure signals
3. Back-Test Execution – A Backtest class applies signals to price series while accounting for slippage and transaction costs
4. Performance Reporting – Scripts output annualized returns, Sharpe ratios, maximum drawdowns, and equity curve visualizations

This architecture allows researchers to swap data providers, modify signal logic, or integrate external libraries like pandas-ta without touching core back-testing components.

Understanding the Bitcoin Overnight Seasonality Effect

The Bitcoin overnight seasonality strategy exploits the empirically observed tendency for Bitcoin's price to move in predictable directions between the close of one trading day and the open of the next. The implementation in static/strategies/intraday-seasonality-in-bitcoin.py processes minute-level BTC/USD data to construct and test this hypothesis.

Signal Construction Logic

The core signal derives from the overnight return, calculated as the logarithmic price change from the previous day's close to the current day's open:

import numpy as np

# Calculate overnight return

df['overnight_ret'] = np.log(df['Open'] / df['Close'].shift(1))

The script evaluates three distinct configurations:

• Long-only – Takes positions only when the signal predicts positive overnight moves
• Short-only – Takes positions only when the signal predicts negative overnight moves
• Long-short – Dynamically switches direction based on the sign of the expected return

Data Acquisition and Processing

The strategy loads historical price data through helper functions that interface with cryptocurrency exchanges or local CSV files. The load_data() function standardizes raw price feeds into a pandas DataFrame with explicit Open, High, Low, Close, and Volume columns required by the back-test engine.

Back-Test Engine Implementation

Each strategy script instantiates a Backtest class that simulates execution with realistic market frictions. The engine accepts the signal series, applies position sizing rules, and iterates through the price history to calculate portfolio values.

Key capabilities of the back-test implementation include:

• Transaction cost modeling – Configurable commission and spread parameters
• Slippage simulation – Realistic fill prices based on volatility and volume
• Position limits – Maximum exposure constraints to prevent excessive leverage
• Performance metrics – Automated calculation of risk-adjusted returns and drawdown statistics

The run_backtest() method executes the simulation and returns a results object containing equity curves, trade logs, and summary statistics.

Practical Implementation Examples

Running the Strategy Directly

Execute the Bitcoin overnight seasonality back-test from the terminal to generate immediate performance reports and equity curve plots:

# From the repository root

python static/strategies/intraday-seasonality-in-bitcoin.py

The script outputs a performance summary to the console and saves visualization files to the outputs/ directory.

Importing as a Python Module

Import the strategy into existing research notebooks or algorithmic trading pipelines using Python's import machinery:

import importlib.util
import pathlib

# Load the script as a module

script_path = pathlib.Path("static/strategies/intraday-seasonality-in-bitcoin.py")
spec = importlib.util.spec_from_file_location("btc_overnight", script_path)
btc_overnight = importlib.util.module_from_spec(spec)
spec.loader.exec_module(btc_overnight)

# Run the back-test programmatically

results = btc_overnight.run_backtest()
print(results.summary())

Extending the Strategy with Volatility Filters

Modify the base signal to incorporate risk management by filtering trades based on realized volatility:

import pandas as pd
import numpy as np

def filtered_signal(df):
    # Original overnight return calculation

    df['overnight_ret'] = np.log(df['Open'] / df['Close'].shift(1))
    
    # Compute 20-day realized volatility

    df['vol'] = df['overnight_ret'].rolling(20).std()
    
    # Generate signal only when volatility is below median

    thresh = df['vol'].median()
    df['signal'] = np.where(df['vol'] < thresh, np.sign(df['overnight_ret']), 0)
    return df['signal']

# Pass the custom generator to the back-test engine

results = btc_overnight.run_backtest(signal_generator=filtered_signal)

Key Files for Implementation

• static/strategies/intraday-seasonality-in-bitcoin.py – Primary implementation of the Bitcoin overnight seasonality back-test
• static/strategies/volatility-risk-premium-effect.py – Reference implementation showing volatility factor integration
• static/strategies/turn-of-the-month-in-equity-indexes.py – Demonstrates calendar-based seasonality patterns for cross-asset comparison
• .vscode/launch.json – Debugging configuration for stepping through strategy execution

Summary

• The Bitcoin overnight seasonality strategy resides in static/strategies/intraday-seasonality-in-bitcoin.py as a fully self-contained Python script
• Overnight returns are calculated using np.log(df['Open'] / df['Close'].shift(1)) to capture close-to-open price movements
• The repository implements a Backtest class in each script that handles execution simulation with slippage and transaction costs
• Three variants are tested: long-only, short-only, and long-short configurations
• Scripts can run directly from the command line or be imported as modules for integration with larger research pipelines
• The architecture supports easy extension with custom filters, such as volatility-based position sizing

Frequently Asked Questions

What data sources does the Bitcoin overnight strategy support?

The script uses helper functions to ingest minute-level BTC/USD data, typically from cryptocurrency exchanges like Binance or aggregated sources like Yahoo Finance. The load_data() function in the script standardizes the input format, allowing users to substitute alternative data providers by modifying only the data acquisition layer without changing the signal generation or back-test logic.

How does the overnight return calculation capture the seasonality effect?

The calculation np.log(df['Open'] / df['Close'].shift(1)) measures the logarithmic price change between the previous day's closing price and the current day's opening price. This specific interval isolates price movements that occur during typical overnight hours when traditional equity markets are closed but cryptocurrency markets remain active, revealing patterns specific to this after-hours trading period.

Can I combine this strategy with other technical indicators?

Yes. Because the script exposes a signal_generator parameter in the run_backtest() method, you can pass custom functions that combine the overnight return signal with momentum oscillators, volume profiles, or volatility metrics. The self-contained architecture means you can import pandas-ta or similar libraries and layer additional logic without modifying the core back-test engine.

Does the repository include tools for live trading execution?

No. The awesome-systematic-trading repository focuses exclusively on research and back-testing. While the signal generation logic can theoretically be adapted for live execution, the current implementation in static/strategies/intraday-seasonality-in-bitcoin.py is designed for historical simulation and analysis only. The .vscode/ directory provides debugging configurations to facilitate strategy development, not live trading infrastructure.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}