QuantDinger

Your Private AI Quant Operating System

One deployable stack for charting, AI market research, Python indicators & strategies, backtests, and live execution—on your own servers and your own keys.

Self-hosted quantitative platform: from idea and AI-assisted coding to paper-style workflows and exchange-connected live trading, with optional multi-user and billing primitives for operators.

English · 简体中文 · 日本語 · 한국어 · ไทย · Tiếng Việt · العربية

SaaS · Video Demo · Website · AWS Marketplace

Try in 2 minutes

Lightest path: pull images, start the stack — no npm, no Vue source folder, and no docker compose up --build. The UI comes from GHCR (quantdinger-frontend:3.0.10 by default); only the backend is built locally on first boot.

Prerequisites: Docker with Compose v2 (Docker Desktop on Windows/macOS). Git for the standard path below. Node.js is not required.

Lightest: two files only (no `git clone`)

If you only need a running stack and can reach GHCR + Docker Hub (or a mirror):

curl -O https://raw.githubusercontent.com/brokermr810/QuantDinger/main/docker-compose.ghcr.yml
curl -o backend.env https://raw.githubusercontent.com/brokermr810/QuantDinger/main/backend_api_python/env.example
docker compose -f docker-compose.ghcr.yml pull
docker compose -f docker-compose.ghcr.yml up -d

SECRET_KEY is auto-generated on first backend start. Open http://localhost:8888.

Standard: clone this repo (recommended for config & docs)

macOS / Linux (Bash) — one line

git clone https://github.com/brokermr810/QuantDinger.git && cd QuantDinger && cp backend_api_python/env.example backend_api_python/.env && chmod +x scripts/generate-secret-key.sh && ./scripts/generate-secret-key.sh && docker compose pull && docker compose up -d

Windows (PowerShell) — folder name after clone is QuantDinger (same spelling as the GitHub repo; cd quantdinger also works on Windows when case-insensitive):

git clone https://github.com/brokermr810/QuantDinger.git
Set-Location QuantDinger
Copy-Item backend_api_python\env.example -Destination backend_api_python\.env
$key = & python -c "import secrets; print(secrets.token_hex(32))" 2>$null
if (-not $key) { $key = & py -c "import secrets; print(secrets.token_hex(32))" 2>$null }
if (-not $key) { $key = & python3 -c "import secrets; print(secrets.token_hex(32))" 2>$null }
if (-not $key) { Write-Error "Install Python 3 from python.org (tick 'Add to PATH') or use Git Bash with the Bash one-liner above." }
(Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding utf8
docker compose pull
docker compose up -d

Use docker compose (space). Legacy docker-compose (hyphen) works on many installs. Git Bash can run the Bash one-liner as-is.

Do not use docker compose up --build for a normal install

--build forces a frontend build from ./QuantDinger-Vue/. That directory is not shipped in this repo — you will see QuantDinger-Vue not found or extra pulls for node:18-alpine.

Goal	Command
First-time / routine start	`docker compose pull` then `docker compose up -d`
Rebuild backend only after code changes	`docker compose up -d --build backend`
Hack on Vue UI from source	Clone QuantDinger-Vue into `./QuantDinger-Vue/`, then `docker compose up -d --build`

Slow or failed docker pull (China / VPN)

System VPN often does not proxy Docker Desktop. Either configure Docker Desktop → Settings → Proxies (e.g. http://127.0.0.1:7890 for Clash), or add to a repository-root .env:

IMAGE_PREFIX=docker.m.daocloud.io/library/

Then run docker compose pull again. Errors like content size of zero or connectex on registry-1.docker.io are registry/network issues, not application bugs.

Then open http://localhost:8888, sign in with quantdinger / 123456, and change the default admin password before any real use.

For step-by-step detail and troubleshooting, see Installation & first-time setup.

Related repositories

This repo ships the backend, Docker Compose stack, and documentation. The web UI image is published independently to GHCR by the sibling Vue repo. Use the sibling repos when you need source-level UI changes or the mobile app:

Repository	What it is
QuantDinger (this repo)	Backend (Flask/Python), Compose stack, docs
QuantDinger-Vue	Web frontend source (Vue) — tagging `v*` publishes `ghcr.io/brokermr810/quantdinger-frontend` automatically
QuantDinger-Mobile	Open-source mobile client — pairs with your self-hosted or SaaS backend

Note: Node.js is only required if you build the web UI from QuantDinger-Vue; the default Docker quick start pulls the published image and does not need it.

Use it from an AI agent (Cursor / Claude Code / Codex / MCP)

QuantDinger ships an Agent Gateway at /api/agent/v1 plus a small MCP server (quantdinger-mcp on PyPI) that wraps it as Model Context Protocol tools. Issue a token once and your AI client can read markets, manage strategies, run backtests, and (paper-only by default) place trades — without ever seeing your exchange keys or your admin JWT.

Every agent call is audit-logged, and trading-class tokens are paper-only by default. Live execution requires both paper_only=false on the token AND AGENT_LIVE_TRADING_ENABLED=true on the server.

Two backends, same client config — only QUANTDINGER_BASE_URL differs:

Hosted (30 s try-out) — sign up at ai.quantdinger.com → Sidebar → Agent Tokens → Issue Token. Locked to paper_only=true, no real-money orders.
Self-hosted (this repo) — after the Try in 2 minutes Docker bring-up, open http://localhost:8888/#/agent-tokens. You control scopes, allowlists, rate limits, and live-trading flag.

Then point Cursor / Claude Code / Codex at the MCP server (.cursor/mcp.json template: docs/agent/cursor-mcp.example.json):

{ "mcpServers": { "quantdinger": {
  "command": "uvx", "args": ["quantdinger-mcp"],
  "env": { "QUANTDINGER_BASE_URL": "http://localhost:8888",
           "QUANTDINGER_AGENT_TOKEN": "qd_agent_xxxxxxxx" }
} } }

Full setup recipe — local stdio config, remote HTTP transport, Claude Code CLI helper, example agent prompts, audit-log walkthrough: docs/agent/MCP_SETUP.md.

Deeper references: AI Integration design · Quickstart with curl · OpenAPI 3.0 spec · MCP server README

Product overview

QuantDinger is a self-hosted quantitative OS: AI-assisted research, Python-native strategies (IndicatorStrategy + ScriptStrategy), backtesting, and live trading (crypto, IBKR, MT5, Alpaca)—with optional multi-user roles, notifications, credits, and USDT billing. It replaces a patchwork of charts, notebooks, bots, and disconnected LLM chats with one Compose stack and your credentials in Postgres + .env.

Typical DIY stack	QuantDinger
Chat AI separate from execution	Analysis, NL→code, backtests, and execution in one product
Many tools wired by hand	Nginx + Vue UI, Flask API, workers, exchange/LLM adapters
Opaque SaaS keys	Your infra, your exchange keys, your LLM keys

Audience: traders and quants, Python strategy authors, small teams building internal or commercial trading products.

Visual Tour

_{▶ Watch Product Demo on YouTube} _{Click the preview card above to open the full video walkthrough.}
_{Indicator IDE, charting, backtest, and quick trade}	_{AI asset analysis and opportunity radar}
_{Trading bot workspace and automation templates}	_{Strategy live operations, performance, and monitoring}

Features at a glance

Research & AI — Multi-LLM analysis, watchlists, analysis history; optional ensemble/calibration; NL→indicator/strategy; post-backtest AI hints. Agent Gateway + MCP for Cursor / Claude Code / Codex.
Build — IndicatorStrategy (dataframe signals, chart overlays) and ScriptStrategy (on_bar, explicit orders); professional chart UI.
Validate — Server-side backtests, metrics, equity curves, strategy snapshots.
Operate — Crypto execution, quick trade, IBKR / MT5 / Alpaca (US stocks, ETFs, crypto), notifications (Telegram, email, SMS, Discord, webhooks). Unified Broker Accounts page centralises connection, account KPIs, positions and open-order management across all brokers.
Platform — Docker Compose, Postgres, Redis, OAuth, multi-user patterns, credits / membership / USDT billing toggles.

Architecture

Stack: Nginx serves the prebuilt Vue app (published as ghcr.io/brokermr810/quantdinger-frontend); Flask API runs strategy/AI/billing services; PostgreSQL holds state; Redis backs workers. Exchanges, brokers, LLMs, and payments plug in through env-driven adapters. Crypto market data and order execution paths are separated by design.

Runtime (short): data feeds → backtest/strategy engine → live runtime → exchange adapters; pending orders dispatched per venue.

System diagram

flowchart LR
    U[Trader / Operator / Researcher]

    subgraph FE[Frontend Layer]
        WEB[Vue Web App]
        NG[Nginx Delivery]
    end

    subgraph BE[Application Layer]
        API[Flask API Gateway]
        AI[AI Analysis Services]
        STRAT[Strategy and Backtest Engine]
        EXEC[Execution and Quick Trade]
        BILL[Billing and Membership]
    end

    subgraph DATA[State Layer]
        PG[(PostgreSQL 16)]
        REDIS[(Redis 7)]
        FILES[Logs and Runtime Data]
    end

    subgraph EXT[External Integrations]
        LLM[LLM Providers]
        EXCH[Crypto Exchanges]
        BROKER[IBKR / MT5 / Alpaca]
        MARKET[Market Data / News]
        PAY[TronGrid / USDT Payment]
        NOTIFY[Telegram / Email / SMS / Webhook]
    end

    U --> WEB
    WEB --> NG --> API
    API --> AI
    API --> STRAT
    API --> EXEC
    API --> BILL

    AI --> PG
    STRAT --> PG
    EXEC --> PG
    BILL --> PG
    API --> REDIS
    API --> FILES

    AI --> LLM
    AI --> MARKET
    EXEC --> EXCH
    EXEC --> BROKER
    BILL --> PAY
    API --> NOTIFY

Installation & first-time setup (Docker Compose)

Already ran Try in 2 minutes? Skip this section — it's the same outcome, just expanded into a step-by-step checklist for first-time deployers and operations folks who want to understand every knob.

This section mirrors a typical “local deploy” path: prepare the host → obtain the code → configure secrets → start the stack → verify → harden → optionally wire AI. Node.js is not required: the frontend service pulls ghcr.io/brokermr810/quantdinger-frontend directly, so Nginx serves the SPA without any local build step.

Prerequisites

Item	Notes
Docker + Docker Compose v2	Used for Postgres, Redis, API, and static UI.
`git`	To clone this repository.
Ports (defaults)	`8888` (web), `5000` (API, bound to 127.0.0.1), `5432` / `6379` (DB/Redis, loopback by default). Change via root `.env` if they collide.
Disk	Postgres volume grows with users, strategies, and logs; plan a few GB minimum for serious use.

1) Clone the repository

git clone https://github.com/brokermr810/QuantDinger.git
cd QuantDinger

2) Create backend configuration (mandatory)

cp backend_api_python/env.example backend_api_python/.env

Almost all runtime behavior is driven by backend_api_python/.env (database URL, admin user, LLM keys, workers, billing toggles, etc.). The optional repository root .env only adjusts Compose-level concerns such as ports and image mirrors (IMAGE_PREFIX).

3) Set `SECRET_KEY` before the first boot (mandatory)

The API refuses to start if SECRET_KEY is still the placeholder from env.example. This blocks accidental insecure deployments.

Linux / macOS (recommended):

./scripts/generate-secret-key.sh

The script overwrites the SECRET_KEY= line in backend_api_python/.env using Python’s secrets module.

Manual (any OS): generate a long random string (for example 64 hex chars) and set SECRET_KEY=... in backend_api_python/.env.

4) Start the stack

docker compose pull
docker compose up -d

frontend — pulls ghcr.io/brokermr810/quantdinger-frontend:3.0.10 (no local Vue tree required).
backend — built from ./backend_api_python on first start if no local image exists yet.
Do not run docker compose up -d --build unless you have cloned QuantDinger-Vue into ./QuantDinger-Vue/ for UI development.

Services: postgres, redis, backend, frontend (see docker-compose.yml).

Alternative: zero-repo install from GHCR (lightest)

Prebuilt multi-arch (amd64/arm64) images for both backend and frontend — no git clone:

curl -O https://raw.githubusercontent.com/brokermr810/QuantDinger/main/docker-compose.ghcr.yml
curl -o backend.env https://raw.githubusercontent.com/brokermr810/QuantDinger/main/backend_api_python/env.example
docker compose -f docker-compose.ghcr.yml pull
docker compose -f docker-compose.ghcr.yml up -d

The backend entrypoint auto-generates a random SECRET_KEY on first start and applies the schema (migrations/init.sql) idempotently. Edit backend.env for persistent overrides (API keys, OAuth, broker credentials). Compose orchestration knobs go in a separate .env (optional) — e.g. pin a version:

# Common case: lockstep both sides to one tag
IMAGE_TAG=3.0.10

# Advanced (opt-in): decouple sides. Either var alone overrides only
# that side; the other still follows IMAGE_TAG.
# BACKEND_TAG=v3.0.9
# FRONTEND_TAG=v3.1.0-rc1

# BACKEND_IMAGE=ghcr.io/<your-fork>/quantdinger-backend     # optional, for forks
# FRONTEND_IMAGE=ghcr.io/<your-fork>/quantdinger-frontend

Tag resolution: BACKEND_TAG / FRONTEND_TAG → IMAGE_TAG → compose defaults. Without a root .env, docker-compose.yml pulls ghcr.io/brokermr810/quantdinger-frontend:3.0.10 (bundled frontend/dist was removed); docker-compose.ghcr.yml defaults to backend 3.0.9 + frontend 3.0.10.

Alternative: build the frontend from Vue source

If you have access to the QuantDinger-Vue repo and want to iterate on UI source (theme tweaks, forks, debugging) instead of pulling the published image, clone it into the ./QuantDinger-Vue/ slot at the repo root (gitignored) and let Compose build from there:

git clone https://github.com/brokermr810/QuantDinger-Vue.git QuantDinger-Vue
docker compose up -d --build      # frontend builds from ./QuantDinger-Vue

Without --build Compose pulls the GHCR image as usual — the ./QuantDinger-Vue/ directory is referenced lazily and may not exist. Point FRONTEND_SRC_PATH=/abs/path/to/QuantDinger-Vue if you'd rather keep the source somewhere else. The locally built image is tagged the same way as the published one (FRONTEND_TAG / IMAGE_TAG rules apply), so it slots into the rest of the stack with no further changes.

5) Verify and sign in

Check	URL / command
Web UI	`http://localhost:8888` (override host/port with `FRONTEND_HOST` / `FRONTEND_PORT` in root `.env` if needed).
API health	`http://localhost:5000/api/health`
Logs	`docker-compose logs -f backend`

Default admin (change immediately in production):

User: quantdinger
Password: 123456 (from env.example; override with ADMIN_USER / ADMIN_PASSWORD in .env before first use if you prefer).

Also set FRONTEND_URL in backend_api_python/.env to the URL users actually use (including https:// behind a reverse proxy); it affects redirects, CORS-related settings, and some generated links.

6) Optional: enable AI features

AI analysis, NL→code, and related flows need at least one LLM provider configured. Open backend_api_python/env.example, find the AI / LLM block, copy the relevant keys into your .env (for example LLM_PROVIDER + OPENROUTER_API_KEY, or another supported provider). Restart the backend after edits.

7) Windows notes

Use Docker Desktop (WSL2 backend recommended). From PowerShell in the repo root:

git clone https://github.com/brokermr810/QuantDinger.git
Set-Location QuantDinger
Copy-Item backend_api_python\env.example -Destination backend_api_python\.env
$key = py -c "import secrets; print(secrets.token_hex(32))"
(Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding UTF8
docker compose pull
docker compose up -d

If py is not on PATH, use python or python3 in the one-liner that generates $key. Line endings should remain UTF-8; avoid editors that strip newlines from .env.

Troubleshooting (first boot)

Symptom	What to check
`QuantDinger-Vue` not found	You used `--build` without cloning Vue source. Use `docker compose up -d` (no `--build`) or clone into `./QuantDinger-Vue/` first.
`redis` / `python` / `node` pull fails, `content size of zero`	Docker Hub unreachable from Docker Desktop. Set root `.env` `IMAGE_PREFIX=docker.m.daocloud.io/library/` and/or configure Docker Desktop → Proxies (system VPN alone is often not enough).
Backend exits immediately	`SECRET_KEY` still default, or invalid `.env` syntax. Read `docker compose logs backend`.
Blank page or API errors from browser	`FRONTEND_URL` / origins mismatch; API not reachable from the host you opened.
Port already in use	Another Postgres, Redis, or local service on `5432` / `6379` / `5000` / `8888`. Adjust variables in root `.env` per `docker-compose.yml`.
Many live strategies, “start denied”	Raise `STRATEGY_MAX_THREADS` in `backend_api_python/.env` and restart API (see comments in `env.example`).

Common Docker commands

docker compose ps
docker compose logs -f backend
docker compose restart backend
docker compose pull
docker compose up -d
docker compose up -d --build backend   # backend code changes only
docker compose down

Optional root `.env` (Compose only)

For custom ports or mirror/prefix for base images (slow Docker Hub pulls), create a file named .env in the repository root (same directory as docker-compose.yml):

FRONTEND_PORT=3000
BACKEND_PORT=127.0.0.1:5001
IMAGE_PREFIX=docker.m.daocloud.io/library/

Production-style TLS, domain, and reverse-proxy placement are covered in Cloud deployment.

Suggested first session (product walkthrough)

After the stack is healthy: (1) run an AI asset / market analysis so LLM and data paths are verified; (2) open the Indicator IDE, load a symbol, and run a signal backtest on a small date range; (3) optionally use AI code generation to draft an indicator, then edit the Python; (4) when ready, attach exchange API keys (profile / credentials), use test connection, then explore live strategy or quick trade with execution mode you intend. This order surfaces configuration issues early before real capital.

Minimal Example: Python Indicator Strategy

This is the kind of Python-native strategy logic QuantDinger is designed for:

# @param sma_short int 14 Short moving average
# @param sma_long int 28 Long moving average

sma_short_period = params.get('sma_short', 14)
sma_long_period = params.get('sma_long', 28)

my_indicator_name = "Dual Moving Average Strategy"
my_indicator_description = f"SMA {sma_short_period}/{sma_long_period} crossover"

df = df.copy()
sma_short = df["close"].rolling(sma_short_period).mean()
sma_long = df["close"].rolling(sma_long_period).mean()

buy = (sma_short > sma_long) & (sma_short.shift(1) <= sma_long.shift(1))
sell = (sma_short < sma_long) & (sma_short.shift(1) >= sma_long.shift(1))

df["buy"] = buy.fillna(False).astype(bool)
df["sell"] = sell.fillna(False).astype(bool)

See full examples:

Supported Markets, Brokers, and Exchanges

Crypto Exchanges

Venue	Coverage
Binance	Spot, Futures, Margin
OKX	Spot, Perpetual, Options
Bitget	Spot, Futures, Copy Trading
Bybit	Spot, Linear Futures
Coinbase	Spot
Kraken	Spot, Futures
KuCoin	Spot, Futures
Gate.io	Spot, Futures
Deepcoin	Derivatives integration
HTX	Spot, USDT-margined perpetuals

Traditional Markets

Market	Broker / Source	Execution
US Stocks	IBKR, Alpaca, Yahoo Finance, Finnhub	Via IBKR or Alpaca (paper + live)
ETFs	Alpaca	Via Alpaca (paper + live)
Forex	MT5, OANDA	Via MT5
Futures	Exchange and data integrations	Data and workflow support

Broker Accounts page (/broker-accounts, v3.0.5+) — IBKR, MT5 and Alpaca share a single unified management page: per-broker connect form, account KPIs, positions table and open-order management with one-click cancel. Multi-tenant safe: each user's session is isolated via BrokerSessionRegistry, so one user reconnecting doesn't kick everyone else off.

Strategy Development Modes

QuantDinger supports two main strategy authoring models:

IndicatorStrategy

dataframe-based Python scripts
buy / sell signal generation
chart rendering and signal-style backtests
best for research, indicator logic, and visual strategy prototyping

ScriptStrategy

event-driven on_init(ctx) / on_bar(ctx, bar) scripts
explicit runtime control with ctx.buy(), ctx.sell(), ctx.close_position()
best for stateful strategies, execution-oriented logic, and live alignment

For the full developer workflow, see:

The example scripts live in docs/examples/ and are kept aligned with the current strategy development guides.

Repository Layout

QuantDinger/
├── backend_api_python/      # Open backend source code
│   ├── app/routes/          # REST endpoints
│   ├── app/services/        # AI, trading, billing, backtest, integrations
│   ├── migrations/init.sql  # Database initialization
│   ├── env.example          # Main environment template
│   └── Dockerfile
├── docs/                    # Product, strategy, and deployment documentation
├── docker-compose.yml       # Web UI via GHCR; optional ./QuantDinger-Vue/ for local UI builds
├── LICENSE
└── TRADEMARKS.md

Configuration Areas

Use backend_api_python/env.example as the primary template. Key areas include:

Area	Examples
Authentication	`SECRET_KEY`, `ADMIN_USER`, `ADMIN_PASSWORD`
Database	`DATABASE_URL`
LLM / AI	`LLM_PROVIDER`, `OPENROUTER_API_KEY`, `OPENAI_API_KEY`
OAuth	`GOOGLE_CLIENT_ID`, `GITHUB_CLIENT_ID`
Security	`TURNSTILE_SITE_KEY`, `ENABLE_REGISTRATION`
Billing	`BILLING_ENABLED`, `BILLING_COST_AI_ANALYSIS`
Membership	`MEMBERSHIP_MONTHLY_PRICE_USD`, `MEMBERSHIP_MONTHLY_CREDITS`
USDT Payment	`USDT_PAY_ENABLED`, `USDT_TRC20_XPUB`, `TRONGRID_API_KEY`
Optional data APIs	`TWELVE_DATA_API_KEY`, `FINNHUB_API_KEY`, `TIINGO_API_KEY`, `ADANOS_API_KEY`
Proxy	`PROXY_URL`
Workers	`ENABLE_PENDING_ORDER_WORKER`, `ENABLE_PORTFOLIO_MONITOR`, `ENABLE_REFLECTION_WORKER`
AI tuning	`ENABLE_AI_ENSEMBLE`, `ENABLE_CONFIDENCE_CALIBRATION`, `AI_ENSEMBLE_MODELS`

Documentation

Doc	Notes
Changelog	Releases & migrations
README (中文)	Chinese overview
JA · KO · TH · VI · AR	Concise localized READMEs (Japanese, Korean, Thai, Vietnamese, Arabic)
Cloud deployment	HTTPS, reverse proxy, production
Multi-user	Postgres multi-tenant patterns
Agent environment · AI integration · Quickstart · OpenAPI · MCP server	Coding agents & MCP (`quantdinger-mcp` on PyPI)

Strategy: EN · CN · TW · JA · KO · Cross-sectional EN / CN · Examples

Integrations & alerts: IBKR · MT5 EN / CN · OAuth EN / CN · Telegram / Email / SMS configs under docs/ (NOTIFICATION_*).

FAQ

Is QuantDinger really self-hosted?

Yes. The default deployment model is your own Docker Compose stack with your own database, Redis instance, credentials, and environment configuration.

Is QuantDinger only for crypto trading?

No. Crypto is a major focus, but the platform also includes IBKR and Alpaca workflows for US stocks / ETFs (Alpaca additionally covers crypto) and MT5 workflows for forex.

Can I write strategies directly in Python?

Yes. QuantDinger supports both dataframe-style IndicatorStrategy development and event-driven ScriptStrategy development. You can also use AI to generate a starting point and then edit it yourself.

Is this a research tool or a live trading platform?

It is both. QuantDinger is built to connect AI research, charting, strategy development, backtesting, quick trade flows, and live execution operations in one system.

Can I use QuantDinger commercially?

The backend is licensed under Apache 2.0. The web frontend source (QuantDinger-Vue) uses a separate source-available license—review both and contact the project for commercial frontend authorization if needed. The mobile app repo is open source under its own license (see that repository).

Is there a mobile app?

Yes—see QuantDinger-Mobile (open source). It connects to the same backend you self-host or to SaaS.

Exchange Partner Links

The following links are available in-app under Profile -> Open account and may qualify users for trading-fee rebates depending on venue policies.

Exchange	Signup Link
Binance	Register
Bitget	Register
Bybit	Register
OKX	Register
Gate.io	Register
HTX	Register

License and Commercial Terms

Backend source code is licensed under Apache License 2.0. See LICENSE.
This repository distributes the frontend UI here as prebuilt files for integrated deployment.
The frontend source code is available separately at QuantDinger Frontend under the QuantDinger Frontend Source-Available License v1.0.
Under that frontend license, non-commercial use and eligible qualified non-profit use are permitted free of charge, while commercial use requires a separate commercial license from the copyright holder.
Trademark, branding, attribution, and watermark usage are governed separately and may not be removed or altered without permission. See TRADEMARKS.md.

For commercial licensing, frontend source access, branding authorization, or deployment support:

Legal Notice and Compliance

QuantDinger is intended for lawful research, education, and compliant trading only—not for fraud, market manipulation, sanctions evasion, money laundering, or other illegal activity. Operators must follow applicable laws, licensing, and exchange rules in every jurisdiction where they deploy. This project does not provide legal, tax, investment, or regulatory advice. You use the software at your own risk; to the extent permitted by law, contributors disclaim liability for trading losses, service interruption, or regulatory enforcement arising from use or misuse.

Community and Support

Support the Project

Crypto donations:

0x96fa4962181bea077f8c7240efe46afbe73641a7

Star History

Acknowledgements

QuantDinger stands on top of a strong open-source ecosystem. Special thanks to projects such as:

P.S. — A Note on the Name

QuantDinger is a small tribute to Erwin Schrödinger — the "-dinger" in our name is the tail of "Schrödinger". The cat in the box was a thought experiment; every un-fired strategy is its own little version of it — simultaneously winning and losing until the order actually fills. Backtests open the box. Live trading collapses the wavefunction. Trade carefully.

_{If QuantDinger is useful to you, a GitHub star helps the project a lot.}

Name		Name	Last commit message	Last commit date
Latest commit History 342 Commits
.cursor/skills/quantdinger-agent-workflow		.cursor/skills/quantdinger-agent-workflow
.github		.github
backend_api_python		backend_api_python
docs		docs
mcp_server		mcp_server
scripts		scripts
.dockerignore		.dockerignore
.env.example		.env.example
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
CONTRIBUTORS.md		CONTRIBUTORS.md
DEVELOPMENT.md		DEVELOPMENT.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
TRADEMARKS.md		TRADEMARKS.md
docker-compose.ghcr.yml		docker-compose.ghcr.yml
docker-compose.yml		docker-compose.yml

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

QuantDinger

Your Private AI Quant Operating System

Contents

Try in 2 minutes

Lightest: two files only (no git clone)

Standard: clone this repo (recommended for config & docs)

Related repositories

Use it from an AI agent (Cursor / Claude Code / Codex / MCP)

Product overview

Visual Tour

Features at a glance

Architecture

System diagram

Installation & first-time setup (Docker Compose)

Prerequisites

1) Clone the repository

2) Create backend configuration (mandatory)

3) Set SECRET_KEY before the first boot (mandatory)

4) Start the stack

Alternative: zero-repo install from GHCR (lightest)

Alternative: build the frontend from Vue source

5) Verify and sign in

6) Optional: enable AI features

7) Windows notes

Troubleshooting (first boot)

Common Docker commands

Optional root .env (Compose only)

Suggested first session (product walkthrough)

Minimal Example: Python Indicator Strategy

Supported Markets, Brokers, and Exchanges

Crypto Exchanges

Traditional Markets

Strategy Development Modes

IndicatorStrategy

ScriptStrategy

Repository Layout

Configuration Areas

Documentation

FAQ

Is QuantDinger really self-hosted?

Is QuantDinger only for crypto trading?

Can I write strategies directly in Python?

Is this a research tool or a live trading platform?

Can I use QuantDinger commercially?

Is there a mobile app?

Exchange Partner Links

License and Commercial Terms

Legal Notice and Compliance

Community and Support

Support the Project

Star History

Acknowledgements

P.S. — A Note on the Name

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases 4

Sponsor this project

Uh oh!

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

Lightest: two files only (no `git clone`)

3) Set `SECRET_KEY` before the first boot (mandatory)

Optional root `.env` (Compose only)

Packages