alpha-rptr: one Python strategy running on backtest, paper and live

The stated goal: no code changes between simulated and live

The project description calls it a trading bot for automated algorithmic trading on Binance Futures, Bybit, BitMEX and FTX written in Python, and the README expands on the intent. The trading system aims to offer an easy to use platform for users to test their trading strategies through backtesting and paper trading, as well as to execute trades in live environments. The design goal is stated as minimizing discrepancies between simulated and live trading results, and the README is specific about the payoff: smooth transitions from backtesting to paper trading and finally to live trading, with minimal changes to strategy code at each step. That is the actual product here. The exchanges, the indicators and the order types are the supporting cast. The thing being sold is one strategy file that does not need rewriting every time you change where the orders go.

An event driven design with pre-defined market events

The mechanism underneath is event based. The README says the system is designed around pre-defined events such as market data updates, order updates and trade executions, and that while developing strategies users are expected to have a basic understanding of trading and are not subject to many limitations. So a strategy is a handler for events rather than a loop you write yourself, and the framework takes care of the plumbing around it. The feature list spells out what that plumbing covers: a REST API and websocket implementation for multiple cryptocurrency exchanges, all types of orders including the majority of parameter combinations, with a request if you miss any, and sophisticated order types such as limit orders, stop-loss orders, trailing stop orders, iceberg orders and limit chasing orders. There is also real-time position and order monitoring, and custom strategy implementation so traders can define their own algorithms and indicators.

Five run modes, and why the testnet modes exist

The table of contents in the README lists the run modes explicitly, and this is where the backtesting-to-live story becomes concrete. There is a production trade mode, a demo trade mode, a backtest mode, a hyperopt mode and a stub trade mode, which the README describes as paper trading. Demo here means the exchange's own testnet, and the feature list is specific that testnet is available for Bybit, BitMEX and Binance Futures, letting traders test strategies without risking real funds. Stub trade mode simulates trades with fake funds inside the framework itself. The hyperopt mode is the parameter search layer, and the requirements file shows the hyperopt package is a direct dependency. Between them, the five modes give you a path: optimise parameters in hyperopt, check them against history in backtest, verify the mechanics on a testnet or with stub fills, and only then point the same strategy at a live account.

Installing on macOS and Linux, where TA-Lib is the hard part

The README documents a Python requirement of 3.9.9 and then two platform paths for installing the packages. On macOS it is three commands, because ta-lib is available through Homebrew.

$ wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
$ tar xvzf ta-lib-0.4.0-src.tar.gz
$ cd ta-lib/
$ ./configure --prefix=/usr
$ make
$ sudo make install

After that, the clone and the pip install are the same two commands as on macOS. The dependency list in requirements.txt is broad, which is what a backtesting, plotting and monitoring stack looks like: numpy, scipy, pandas, scikit-learn pinned at 1.3.2, matplotlib for plotting, ta-lib and pyti for indicators, hyperopt for parameter search, websocket-client and bravado for the exchange connections, pybit for the Bybit API, PyQt6 for the interface, discord-webhook and influxdb-client for notifications and metrics, and setuptools capped below 81.

$ brew install ta-lib
$ git clone https://github.com/TheFourGreatErrors/alpha-rptr.git
$ cd alpha-rptr/
$ pip install -r requirements.txt

On Linux you have to build the C library yourself, which the README explains at length. It uses a Python wrapper for the TA-Lib library, which provides a wide range of technical analysis functions for financial markets, but the underlying library is written in C and has to be properly compiled on your system before the Python wrapper can use it. The README warns that the installation process may require some technical knowledge and that you should ensure the C library is properly compiled prior to installation to avoid errors.

Keys live in src/config.py, and that is worth thinking about

The README is explicit about where configuration goes. The src/config.py file is where you set your API keys and other configuration settings, and the first step it describes is to open that file in a text editor or IDE, then look for the binance_keys section of the configuration dictionary. The section on setting keys is the one that stops mid-sentence, so the details of the other exchange sections are not documented in the part of the README that is visible. What is documented is the shape: one section per exchange, holding credentials. The consequence for a real deployment is obvious enough to state. An API key that can place orders is a credential that belongs in a secret store or at minimum in a file that is not committed, and this project expects you to edit a source file in the repository to set it. The repository does carry a .gitignore, so ignoring that path is possible, but the default shape of the workflow is credentials in a file inside the checkout. Treat that file as production code, not as scratch configuration.

Notifications, metrics and the HTML5 backtest workbench

Around the trading core there is a fair amount of tooling, and it is the tooling that makes the framework usable day to day. Discord webhooks and Line notifications are supported for real-time updates, and the requirements file pins discord-webhook at 1.1.0. Metrics can be logged to InfluxDB, with influxdb-client and its ciso8601 extra listed as dependencies. There is an HTML5 workbench for backtests, and the repository has an html/ directory for it, plus a section on plotting in Matplotlib and a section on strategy session persistence, which is how a strategy keeps state between runs, plus an advanced session usage section. The repository also ships a Dockerfile, and the command it runs by default is a good summary of the whole thing.

CMD python3 main.py --test --account binanceaccount1 --exchange binanace --pair BTCUSDT --strategy Sample

That single line shows the CLI shape: a mode flag, an account name, an exchange, a trading pair and a strategy, all as arguments to main.py. The image is based on heroku/heroku:16 and installs the build toolchain including gcc, cmake, libatlas-base-dev and libboost-python-dev before compiling ta-lib from source and installing the Python requirements.

The reference strategies are examples, not products

The README carries a paragraph that any adopter should read before anything else, because it sets the expectation correctly. The implemented reference strategies are provided as examples for educational and reference purposes only, and they are not intended to be used as a fully functional trading strategy for live trading without further modifications and proper testing. The strategies may not be suitable for all market conditions and may result in losses. The list itself is ten entries: Supertrend, Parabolic SAR, MACD, CandleTester, CandleTesterMult, Channel Breakout, Cross SMA, RCI, an Open Close Cross strategy and a TradingView strategy, which is implemented but not currently supported via Gmail integration. For TradingView webhook trading the README points at a separate project instead. Alongside the strategies there is a long indicator library organised by category, covering trend, volatility, momentum, moving averages, bands and channels, pattern recognition, math operators, probability distributions and simulations, regression, normalisation and miscellaneous custom functions, with TA-Lib indicators and many others including custom indicators. The licensing note is equally important: the author of the software is not liable for any losses, damages or other adverse consequences resulting from its use, and the README recommends exercising caution and thoroughly testing a strategy using small sizes over an extended period of time before deploying it with larger sums of money. There is no GitHub release for this project, the default branch is master, the licence is MIT, and the last push was on 2026-06-19, so the code is being worked on but nothing has been tagged as a version you can pin.

Editorial conclusion

Adopt alpha-rptr if you already know how to write trading logic and want one Python codebase that covers backtesting, testnet, paper and live execution across several crypto exchanges. Do not adopt it if you are looking for a turnkey strategy, since the README states the reference strategies are examples for educational and reference purposes only and are not intended for live trading without modification and proper testing. Before you connect a real account, read the disclaimer, test with small sizes over an extended period as the author advises, and set your API keys in src/config.py rather than in a shell environment or a secrets manager you forgot about.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. TheFourGreatErrors/alpha-rptr on GitHub