Platform - Quantstrip

Strategy Automation

Turn Python logic into a 24/7 trading operation

Quantstrip runs your strategies as long-lived background clients on your local machine. A lightweight background service starts on boot, manages all your clients, and keeps them running — no cloud subscription required.

Strategies are just Python classes that inherit from ClientBase. Add a scheduler, connect to your broker, and you have a fully automated strategy in under 50 lines of code.

Auto-starts on system boot via Windows Service Manager
Run multiple clients simultaneously — strategies, reporting jobs, anything
Built-in scheduler for precise timing (e.g. daily at market close)
Graceful stop/restart without losing state

Read the architecture overview

rebalancing_client.py

from quantstrip import ClientBase, db_handler, settings
from IBKR.ib_connect import IB

ALLOCATION = settings.get_by_path('Settings/Strategy/allocation')

class Client(ClientBase):
    def __init__(self, *args):
        super().__init__()
        self.display_name = "Rebalancing Flow"
        self.scheduler.every().day.at(
            "15:45", "America/New_York"
        ).do(self.job)

    def job(self):
        # Open position on day 16, close on last day
        with IB() as ib:
            ib.placeOrder(
                ib.get_next_order_id(),
                contract,
                ib_order(quantity, "Rebalancing", "MKT")
            )

Dashboard

Monitor and control everything from a browser

When the background service starts, it spins up a local web server at 127.0.0.1:8051. From there, a suite of dashboard apps lets you monitor running clients, edit code, query your trade database, and manage configuration — all without touching the command line.

Client Monitor — live status of every running client, stop/start individually
Python Editor — edit and reload client code directly in the browser
SQL Database — query your trade and event history interactively
Logging — structured log viewer per client
Notifications — configure email alerts for trade events

Explore dashboard apps

Client Monitor

Client	Status	Last run
Rebalancing Flow	Running	15:45 today
EOD Report	Running	16:30 today
Risk Monitor	Stopped	Yesterday

Data Model

A built-in database for the full trade lifecycle

Quantstrip ships with a structured SQLite database and a db_handler API that abstracts all the common post-trade operations. Record position opens and closes, query your trade history, and build performance reports — all from Python.

The data model tracks strategy events end-to-end: from the moment a position is opened on day 16 to the close on the last business day of the month, every state transition is recorded with a timestamp and a full audit trail.

Strategy event table with open/close lifecycle tracking
Query directly via the SQL Dashboard app or Python API
Position state used as safety check before each execution
Multi-strategy and multi-broker support via IDs

See the db_handler API

Trade lifecycle

Day 1–15 · Observation

Strategy running, no position. Monitoring asset performance.

Day 16 · Position open

Buy underperformer. Event recorded: event_type = "OPEN"

Day 17–28 · Hold

Position held. State validated each day before any action.

Last business day · Close

Sell position. Event recorded: event_type = "CLOSE"

Python API

A clean Python library for everything Quantstrip

The quantstrip Python package is the single import that gives your client access to the full platform. It exposes ClientBase — the base class that registers your strategy with the background service — plus a set of focused utility modules for the most common operational tasks.

The API is intentionally minimal. Each module has a single responsibility, making it easy to learn and straightforward to extend.

Browse the full API reference

quantstrip modules

ClientBase

Base class for all clients. Handles registration, lifecycle, and scheduling.

db_handler

Read and write strategy events and trade history to the built-in database.

email_manager

Send email notifications on trade events or errors.

settings

Load configuration from JSON without hardcoding values in your strategy.

logging

Structured per-client logging, viewable live in the Dashboard.

Resources & Examples

Go from zero to live strategy faster

The fastest path to a running strategy is a working example. Quantstrip ships with a growing library of fully documented client templates — covering broker connections, strategy patterns, and operational utilities.

The monthly rebalancing strategy is a complete, production-ready example: it connects to Interactive Brokers, retrieves historical data, sizes positions dynamically, and records every trade in the database — fully annotated and ready to adapt.

Annotated strategy templates downloadable from your account
Step-by-step documentation for each template
Broker integration guides (Interactive Brokers included)
Architecture and design pattern guidance for building your own clients

Browse strategy examples

Monthly Rebalancing · Trading Timeline

# Day 16: identify underperformer and open
rate_perf  = rate_price.iloc[0]["close"] / rate_price.iloc[-1]["close"]
stock_perf = stock_price.iloc[0]["close"] / stock_price.iloc[-1]["close"]

if rate_perf > stock_perf:
    contract, qty = stock_contract, int(stock_qty)
else:
    contract, qty = rate_contract, int(rate_qty)

# Always buy the underperformer
ib.placeOrder(ib.get_next_order_id(), contract,
              ib_order(qty, "Rebalancing", "MKT"))

Broker Integration

Connect to your broker with pre-built adapters

Quantstrip provides a broker connectivity layer that abstracts the low-level details of broker APIs behind a clean Python interface. The Interactive Brokers adapter is included and production-tested, covering order placement, historical data retrieval, and position management.

The connection is managed via a context manager, so connections are opened and closed cleanly around each trading job — no lingering sessions, no resource leaks.

Interactive Brokers (IBKR) adapter included
Market and limit order support via ib_order
Historical OHLC data retrieval per contract
Context manager pattern for safe connection handling

See the IBKR integration guide

IBKR connection pattern

from IBKR.ib_connect import IB
from IBKR.ib_objects import ib_order, ib_contract

# Context manager handles connect / disconnect
with IB() as ib:

    # Retrieve 16 days of daily closes
    prices = ib.get_historical_data(
        ib_contract("SPY"), "", "16 D", "1 day"
    )

    # Place a market order
    ib.placeOrder(
        ib.get_next_order_id(),
        ib_contract("SPY"),
        ib_order(22, "Rebalancing", "MKT")
    )