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.
QuantDinger is a self-hosted, local-first quantitative platform: AI-assisted research, Python-native strategies, backtesting, and live trading (crypto, IBKR stocks, MT5 forex) in one product—not a loose collection of scripts and SaaS tabs.
End-to-end architecture: market data feeds the five-layer engine and exits to live execution, closing the quant loop from idea to monitoring.
Prerequisites: Docker with Compose (Docker Desktop on Windows/macOS, or Docker Engine + Compose plugin on Linux), and Git. Node.js is not required (prebuilt UI is in frontend/dist).
One line (or run the same steps separately):
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 up -d --buildIf ./scripts/generate-secret-key.sh fails with “Permission denied”, run chmod +x scripts/generate-secret-key.sh and retry. If docker-compose is not found, try docker compose (Compose V2).
Use PowerShell (not CMD) in a folder where you want the project. Docker Desktop must be running (WSL2 backend recommended).
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 macOS/Linux block above." }
(Get-Content backend_api_python\.env) -replace '^SECRET_KEY=.*$', "SECRET_KEY=$key" | Set-Content backend_api_python\.env -Encoding utf8
docker-compose up -d --buildIf docker-compose is not recognized, use docker compose (space, no hyphen). If Git is missing, install Git for Windows.
If you installed Git for Windows, open Git Bash and you can use the macOS / Linux one-liner above (Bash + chmod + ./scripts/generate-secret-key.sh).
Then open http://localhost:8888, sign in with quantdinger / 123456, and change the default admin password before any real use. For prerequisites, configuration details, first-run checks, and troubleshooting, continue to Installation & first-time setup below.
QuantDinger ships an Agent Gateway at /api/agent/v1 and a small MCP server that wraps it as Model Context Protocol tools. Once you sign in once and issue a token, 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.
Two safety properties are non-negotiable: every agent call is audit-logged, and trading-class tokens are paper-only by default. Live execution requires both
paper_only=falseon the token ANDAGENT_LIVE_TRADING_ENABLED=trueon the server.
The MCP client and the wiring in Step 2 are identical for both paths — only the value of QUANTDINGER_BASE_URL changes.
Path A · Hosted (ai.quantdinger.com) — try it in 30 seconds. Sign up → open Sidebar → Agent Tokens → Issue Token. The hosted instance is locked to paper_only=true and the T (Trading) scope is rejected at issuance — agents can read markets, manage strategies in your tenant, and run backtests, but never route real-money orders. Set QUANTDINGER_BASE_URL=https://ai.quantdinger.com. Best for: trying QuantDinger from Cursor / Claude Code without installing anything; demos; research notebooks against shared datasets.
Path B · Self-hosted (this repo) — production / private data / live trading. After the Try in 2 minutes Docker bring-up, log in as admin and open Sidebar → Agent Tokens (or http://localhost:8888/#/agent-tokens). You decide scopes (incl. T), market/instrument allowlists, rate limits, and whether AGENT_LIVE_TRADING_ENABLED=true is ever flipped. Set QUANTDINGER_BASE_URL=http://localhost:8888 (or your LAN URL). Best for: anyone with their own exchange keys, anyone with private strategies/data, teams behind a VPN, or anyone who eventually wants live execution.
In either path:
- Click Issue Token → name it (
cursor-mcp,claude-research, …). - Pick scopes — start with R + B (read + backtest); add W to let the agent create/edit strategies.
- Copy the token once — the dialog shows the full string once; the server only keeps a SHA-256 hash.
Prefer the CLI? See docs/agent/AGENT_QUICKSTART.md for the equivalent curl.
The MCP server lives in mcp_server/. Two transports work everywhere:
A. Local stdio (Cursor, Claude Code, Codex desktop, etc.) — the server is published on PyPI as quantdinger-mcp. Drop this into .cursor/mcp.json, ~/.config/claude/claude_desktop_config.json, or your client's equivalent (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"
}
}
}
}uvx (install uv) downloads + caches the package on first run; no virtualenv setup. If you prefer pip:
pip install quantdinger-mcp
# then use {"command": "quantdinger-mcp", "args": []}For Claude Code's CLI helper:
claude mcp add quantdinger \
--env QUANTDINGER_BASE_URL=http://localhost:8888 \
--env QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \
-- uvx quantdinger-mcpB. Remote HTTP (cloud agents like OpenClaw / NanoBot, browser IDEs, anything that can't spawn subprocesses) — run the MCP server as a long-lived service, then point clients at the URL:
QUANTDINGER_BASE_URL=https://your-host \
QUANTDINGER_AGENT_TOKEN=qd_agent_xxxxxxxx \
QUANTDINGER_MCP_TRANSPORT=streamable-http \
QUANTDINGER_MCP_HOST=0.0.0.0 \
QUANTDINGER_MCP_PORT=7800 \
quantdinger-mcp
# clients connect to http://your-host:7800Use QUANTDINGER_MCP_TRANSPORT=sse instead for clients that only speak the older SSE transport. Put a reverse proxy in front for TLS and IP allowlisting.
Restart the IDE, then ask things like:
- "Pull the last 90 daily candles for BTC/USDT and tell me what the regime detector says."
- "Backtest the 20/60 SMA crossover on ETH/USDT 4h between 2024-01-01 and 2024-06-30 and stream the result as it runs."
- "Create a strategy named eth-trend-bot, use the indicator I just designed, leave it in
stoppedstate."
Long-running jobs (/api/agent/v1/jobs/{id}/stream) are exposed as SSE so the agent can react to partial results without polling. Every call shows up under Agent Tokens → Audit log with route, scope class, status code, and duration.
If you're editing this repo with Cursor / Claude Code / Codex, the repo also ships a Cursor Skill at .cursor/skills/quantdinger-agent-workflow/SKILL.md that explains the Agent Gateway internals, red lines (no real keys, paper-only by default), and where to verify changes. Read docs/agent/AGENT_ENVIRONMENT_DESIGN.md for the full layered-contracts model.
Deeper links: AI Integration design · Quickstart with curl · OpenAPI 3.0 spec · MCP server README
QuantDinger is built for people who want one controlled environment instead of stitching together chart apps, Jupyter, bots, and dashboards:
- Research: AI-driven analysis, watchlists, and multi-market context (crypto, equities, forex, optional prediction-market workflows).
- Build: Indicator-style (
IndicatorStrategy) and script-style (ScriptStrategy) Python; optional natural-language → code to bootstrap. - Validate: Server-side backtests, metrics, and equity curves tied to the same strategy model you iterate in the UI.
- Operate: Live strategies, quick trade, notifications, and execution adapters—credentials stay in your Postgres-backed vault and
.env. - Grow (optional): Multi-user patterns, credits, memberships, and USDT billing hooks for teams that ship a product, not only a personal bot.
If you are looking for an open-source quant stack, self-hosted AI trading workspace, or NL → Python strategy workflow with a real operator surface, this repository is the integration point.
- Self-hosted by design: your credentials, strategy code, market workflows, and operational data stay under your control.
- Research to execution in one product: AI analysis, charting, strategy logic, backtests, quick trade, and live operations are connected.
- Python-native and AI-assisted: write indicators and strategies directly in Python, or use AI to accelerate drafting and iteration.
- Built for operators, not just demos: Docker Compose, PostgreSQL, Redis, Nginx, health checks, worker toggles, and environment-based configuration.
- Commercialization-ready: memberships, credits, admin management, and USDT payment flows are already part of the stack.
QuantDinger gives you something most trading tools do not:
- one stack instead of five for research, strategy code, backtests, execution, alerts, and operations
- AI that sits inside the workflow, not beside it
- Python flexibility without losing product UX
- private deployment without giving up growth features
| Typical Setup | QuantDinger |
|---|---|
| AI chat tool disconnected from real strategy workflows | AI analysis, AI code generation, backtest feedback, and execution workflows live in one product |
| Separate charting app, Python scripts, bot runner, and notification stack | One deployable platform for charting, strategy logic, runtime services, and alerts |
| Hosted SaaS with limited control over credentials and alpha | Self-hosted architecture with your own infra, keys, and operational data |
| Research tools with no operator layer | Multi-user roles, billing, credits, admin controls, and deployment-ready configuration |
- Traders and quants who want AI-assisted market research without giving up control of infrastructure and data.
- Python strategy developers who want charting, backtests, and live execution in one environment.
- Small teams and studios building internal trading tools or private research platforms.
- Operators and founders who need a deployable product with user management, billing, and admin controls.
- AI-assisted market research for crypto, stocks, forex, and cross-market workflows
- Python-native strategy development for quantitative trading and algorithmic trading teams
- Backtesting and iteration for signal strategies, saved strategies, and execution assumptions
- Private trading infrastructure for teams that want self-hosted deployment and privacy-first operations
- Commercial trading products that need users, billing, credits, and admin controls
▶ 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 |
- Run fast AI-driven market analysis across price action, kline structure, macro/news context, and selected external inputs.
- Store analysis history and memory for repeatable review and future calibration.
- Configure multiple LLM providers such as OpenRouter, OpenAI, Gemini, DeepSeek, and more.
- Optionally enable ensemble and calibration-style flows for more robust AI outputs.
- Build
IndicatorStrategyworkflows for dataframe-based signals, chart overlays, and signal backtests. - Build
ScriptStrategyworkflows for stateful runtime logic, explicit order control, and live execution alignment. - Generate indicator or strategy code from natural language and refine it in Python.
- Visualize indicators, buy/sell signals, and strategy output directly on professional chart interfaces.
- Run historical backtests with stored trades, metrics, and equity curves.
- Backtest both indicator-driven logic and saved strategy records.
- Persist strategy snapshots and review historical runs for reproducibility.
- Use AI-assisted post-backtest analysis to improve parameters and execution assumptions.
- Connect crypto exchanges through a unified execution layer.
- Use quick-trade flows to go from analysis to action faster.
- Monitor open positions, review trade history, and close positions from the platform.
- Run automated or semi-automated strategy workflows with runtime services and workers.
- Crypto spot and derivatives
- US stocks through IBKR
- Forex through MT5
- Prediction market research through Polymarket analysis workflows
- PostgreSQL-backed multi-user system with role-based access patterns.
- OAuth support for Google and GitHub.
- Notification channels including Telegram, Email, SMS, Discord, and Webhooks.
- Membership plans, credits, USDT TRC20 payments, and admin-side billing controls.
QuantDinger is not just "LLM chat added to a trading app". The current AI layer is integrated into the actual research and strategy workflow.
- Structured AI market analysis for quick decision support
- Lower-latency workflow than older multi-hop orchestration
- Useful for daily market review, trade planning, and opportunity screening
- Natural language to Python indicator code
- Natural language to strategy code and config scaffolding
- Better fit for traders who know the idea they want, but want to accelerate implementation
- Historical analysis storage
- Better repeatability and comparison over time
- A foundation for future calibration and reflection loops
- Optional multi-model ensemble configuration
- Confidence calibration and reflection-style worker support
- Better operational path for teams that want more stable AI-assisted workflows
- Backtest outputs can feed into AI-generated suggestions
- Useful for parameter tuning, risk adjustments, and faster iteration
- Analyze prediction markets as a research workflow
- Compare AI view versus market-implied probabilities
- Surface divergence and opportunity scoring
Most trading stacks give you one or two of these pieces. QuantDinger aims to give you the full operating system:
- Self-hosted infrastructure
- AI research workflows
- Python strategy development
- Backtesting
- Live execution
- Portfolio and notification operations
- Commercialization primitives
That combination is the core difference.
- For traders: it shortens the path from idea to execution.
- For quants: it keeps Python and strategy control front and center.
- For operators: it adds the parts most open-source trading projects skip, including users, billing, roles, and deployability.
- For AI-first workflows: it turns analysis into something actionable, reviewable, and eventually automatable.
At a practical level, QuantDinger runs as a self-hosted application stack:
- a prebuilt Vue frontend served by Nginx
- a Flask API backend with Python services
- PostgreSQL for state, users, strategies, and history
- Redis for worker support and runtime coordination
- exchange, broker, AI, payment, and notification integrations through configurable adapters
| Layer | Technology |
|---|---|
| Frontend | Prebuilt Vue application served by Nginx |
| Backend | Flask API, Python services, strategy runtime |
| Storage | PostgreSQL 16 |
| Cache / worker support | Redis 7 |
| Trading layer | Exchange adapters, IBKR, MT5 |
| AI layer | LLM provider integration, memory, calibration, optional workers |
| Billing | Membership, credits, USDT TRC20 payment flow |
| Deployment | Docker Compose with health checks |
- Market data is pulled through a pluggable data layer.
- Backtests run on the server-side strategy engine, including strategy snapshot handling.
- Live strategies run through runtime services that generate order intent.
- Pending orders are then dispatched through exchange-specific execution adapters.
- Crypto live execution is intentionally separated from market-data collection concerns.
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]
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
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 repo ships a prebuilt UI under frontend/dist and Nginx serves it inside the frontend container.
| 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. |
git clone https://github.com/brokermr810/QuantDinger.git
cd QuantDingercp backend_api_python/env.example backend_api_python/.envAlmost 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).
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.shThe 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.
docker-compose up -d --buildServices: postgres, redis, backend, frontend (see docker-compose.yml for healthchecks and port mappings).
| 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(fromenv.example; override withADMIN_USER/ADMIN_PASSWORDin.envbefore 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.
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.
Use Docker Desktop (WSL2 backend recommended). From PowerShell in the repo root:
git clone https://github.com/brokermr810/QuantDinger.git
cd 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 up -d --buildIf 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.
| Symptom | What to check |
|---|---|
| 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). |
docker-compose ps
docker-compose logs -f backend
docker-compose restart backend
docker-compose up -d --build
docker-compose downFor 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.
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.
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:
docs/examples/dual_ma_with_params.pydocs/examples/multi_indicator_composite.pydocs/examples/cross_sectional_momentum_rsi.py
| 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 |
| Market | Broker / Source | Execution |
|---|---|---|
| US Stocks | IBKR, Yahoo Finance, Finnhub | Via IBKR |
| Forex | MT5, OANDA | Via MT5 |
| Futures | Exchange and data integrations | Data and workflow support |
Polymarket is currently supported as a research and analysis workflow, not as direct in-platform live execution. It is useful for market lookup, divergence analysis, opportunity scoring, and AI-assisted review.
QuantDinger supports two main strategy authoring models:
- dataframe-based Python scripts
buy/sellsignal generation- chart rendering and signal-style backtests
- best for research, indicator logic, and visual strategy prototyping
- 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.
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
├── frontend/ # Prebuilt frontend delivery package
│ ├── dist/
│ ├── Dockerfile
│ └── nginx.conf
├── docs/ # Product, strategy, and deployment documentation
├── docker-compose.yml
├── LICENSE
└── TRADEMARKS.md
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 |
| Document | Description |
|---|---|
| Changelog | Version history and migration notes |
| Chinese Overview | Chinese product overview |
| Multi-User Setup | PostgreSQL multi-user deployment |
| Cloud Deployment | Domain, HTTPS, reverse proxy, and cloud rollout |
| Multi-agent environment design | How to structure the repo for Cursor, Claude Code, Codex, and similar coding agents (English) |
| AI / Agent integration design | Versioned Agent Gateway, scopes, MCP, and trading safety so QuantDinger can serve AI agents — not only humans (English) |
| Agent quickstart | Issue a token, call /api/agent/v1, run paper trades, integrate via MCP (English) |
| Agent OpenAPI | Machine-readable contract for the Agent Gateway |
| Guide | EN | CN | TW | JA | KO |
|---|---|---|---|---|---|
| Strategy Development | EN | CN | TW | JA | KO |
| Cross-Sectional Strategy | EN | CN | - | - | - |
| Examples | examples | - | - | - | - |
| Topic | English | Chinese |
|---|---|---|
| IBKR | Guide | - |
| MT5 | Guide | Guide |
| OAuth | Guide | Guide |
| Channel | English | Chinese |
|---|---|---|
| Telegram | Setup | Config |
| Setup | Config | |
| SMS | Setup | Config |
Yes. The default deployment model is your own Docker Compose stack with your own database, Redis instance, credentials, and environment configuration.
No. Crypto is a major focus, but the platform also includes IBKR workflows for US stocks, MT5 workflows for forex, and Polymarket research support.
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.
It is both. QuantDinger is built to connect AI research, charting, strategy development, backtesting, quick trade flows, and live execution operations in one system.
The backend is licensed under Apache 2.0. The frontend source has a separate source-available license. Commercial use is supported, but you should review the licensing terms in this repository and contact the project for frontend/commercial authorization if needed.
| Repository | Purpose |
|---|---|
| QuantDinger | Main repository: backend, deployment stack, docs, prebuilt frontend delivery |
| QuantDinger Frontend | Vue frontend source repository for UI development and customization |
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 |
- 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:
- Website: quantdinger.com
- Telegram: t.me/worldinbroker
- Email: support@quantdinger.com
- QuantDinger is provided for lawful research, education, system development, and compliant trading or operational use only.
- No individual or organization may use this software, any derivative work, or any related service for unlawful, fraudulent, abusive, deceptive, market-manipulative, sanctions-violating, money-laundering, or other prohibited activity.
- Any commercial use, deployment, operation, resale, or service offering based on QuantDinger must comply with all applicable laws, regulations, licensing requirements, sanctions rules, tax rules, data-protection rules, consumer-protection rules, and market or exchange rules in the jurisdictions where it is used.
- Users are solely responsible for determining whether their use of the software is lawful in their country or region, and for obtaining any approvals, registrations, disclosures, or professional advice required by applicable law.
- QuantDinger, its copyright holders, contributors, licensors, maintainers, and affiliated open-source participants do not provide legal, tax, investment, compliance, or regulatory advice.
- To the maximum extent permitted by applicable law, QuantDinger and all related contributors and rights holders disclaim responsibility and liability for any unlawful use, regulatory breach, trading loss, service interruption, enforcement action, or other consequence arising from the use or misuse of the software.
- Want to see the product first? Open the official SaaS or watch the Video Demo.
- Want to self-host quickly? Use Try in 2 minutes for a one-liner, then follow Installation & first-time setup for the full checklist.
- Want to build strategies? Read the Strategy Development Guide. Example scripts live in
docs/examples/and are kept aligned with the guide. - Want cloud or production deployment? Use the Cloud Deployment Guide.
- Want to license or customize it for a business? Contact the team through quantdinger.com.
Crypto donations:
0x96fa4962181bea077f8c7240efe46afbe73641a7
QuantDinger stands on top of a strong open-source ecosystem. Special thanks to projects such as:
If QuantDinger is useful to you, a GitHub star helps the project a lot.