# Lumibot One Python strategy that backtests and then trades live, across eight CCXT exchanges. *https://cryptomarkets.tools/tools/lumibot · Backtesting & Research Libraries* ## Also covered on - [Lumibot on StockMarketStack](https://stockmarketstack.com/tools/lumibot.md) — the same framework against stocks and options, and the licence labelled MIT in error ## Facts ### At a glance | Field | Value | | --- | --- | | Vendor | Lumiwealth | | Category | Backtesting & Research Libraries | | Job | backtesting | | Website | https://lumibot.lumiwealth.com/ | | Pricing model | open-source | | Free tier | true | | Open source | true | | Licence | GPL-3.0 | | Self-hosted | true | | KYC required | false | | Tested hands-on | false | | Last updated | 2026-09-19 | ### Coverage | Field | Value | | --- | --- | | Asset classes | spot, perpetuals | | Chains | none | | Venues | cex, derivatives | | Data latency | realtime | | Platforms | library | | AI features | recommendations | ### Interfaces | Field | Value | | --- | --- | | API | false | | Webhooks | false | | Scripting | Python | | MCP server | false | | Export | csv | ### Capabilities Yes: charting, backtesting, automation, live_trading, paper_trading, alerts No: screening, portfolio_tracking, exchange_import, tax_reporting, news, onchain_data, wallet_tracking, derivatives_analytics *Verified: pricing 2026-09-19; capabilities 2026-09-19; coverage 2026-09-19.* ## What it is A Python framework in which a strategy is a class with lifecycle methods — `initialize`, `on_trading_iteration`, `on_filled_order` — and the same class runs against historical data, a broker's paper account, or real money, with a different data source and broker passed in. That is the entire pitch and it is a good one: it removes the class of bug where the research code and the production code drift apart, which is the most expensive category of mistake in this business. What makes it worth a card in a crypto catalogue rather than a stock one is that the crypto path is real and specific. There is a CCXT broker with per-exchange handling for Coinbase, Kraken, KuCoin, Binance, BitMEX and WEEX, a CCXT backtesting data source that downloads and caches candles locally, and a separate Bitunix broker for USDT perpetual futures with per-order leverage. Crypto strategies set `self.set_market("24/7")` and the framework stops applying an equity session calendar. It is also, as of 2026, a framework that has repositioned itself around LLM agents. Agents live on `self.agents`, can be created in `initialize` and called from any lifecycle method, analyse point-in-time data through DuckDB, mount external MCP servers with tool allowlists, and — the vendor's own words — "the trader submits orders". Agentic backtests replay a cached agent run so a second backtest does not cost another model call. What that means for a reader is in Limitations. **Liveness, and one trap in dating it:** the default branch is `dev`, last commit 2026-09-18, with `lumibot` 4.5.91 on PyPI dated 2026-09-06 and three further releases in the ten days before that. `master` has not moved since 2025-12-18, so anyone checking the obvious branch would date this project nine months wrong. 2,075 stars, 66 open issues and 24 open pull requests. ## Data & coverage **Lumibot ships no data.** It ships adapters, and the crypto one is CCXT. **For backtesting, crypto means candles.** `CcxtBacktestingData` supports minute, hour and day intervals, defaults to Binance as the exchange, and caches downloads in a local database so repeated runs do not re-fetch. There are no trades, no quotes and no order book, and every bar is given a hard-coded `dividend_yield` of zero — a small tell that the data model was built for equities and crypto was fitted into it. **For live trading, the vendor publishes its own confidence levels, and the table is unusually honest.** Its CCXT page opens by saying Lumibot "does **not** automatically support every exchange in the CCXT ecosystem", then grades eight of them: Coinbase, Kraken and WEEX auto-detect their credentials from environment variables; KuCoin, Binance and BitMEX need manual CCXT config; Bybit and OKX are marked "Backtesting or custom config only". Anything else, in the vendor's words, "should not be assumed to work until they are tested in Lumibot". Trading is spot and margin, with market, limit and stop orders. **Bitunix is the perpetuals path** and it is a first-party broker rather than a CCXT one — USDT perpetual futures, leverage set per order, with documented handling for position-mode and order-precision failures. The docs also carry a jurisdictional warning most frameworks leave to the reader: WEEX's terms exclude residents of the United States, Canada and several other countries. **Other data sources, for the rest of the framework:** Yahoo for daily equities, ThetaData for intraday equities and options, Polygon.io for stocks, options, forex and crypto, Databento for futures, a Pandas source for your own files, Interactive Brokers REST, and Polymarket for prediction contracts. ## Integrations Ten brokers: Alpaca, Charles Schwab, Interactive Brokers by REST and by the legacy TWS gateway, Tradier, Tradovate, ProjectX/TopstepX, Polymarket, Bitunix and CCXT. Indicators come from `pandas-ta-classic`; performance reporting from `quantstats-lumi`, the vendor's own fork of QuantStats. A backtest writes a tearsheet as HTML plus trade and indicator files prefixed with the strategy name and date. The AI layer brings its own dependency list — `openai`, `litellm`, `google-genai`, Google's ADK and the `mcp` client package — all of which install with the framework whether or not you use an agent. The quickstart runs on Gemini with a key you supply. ## Limitations **Fees and slippage default to zero, and the code says so explicitly.** The backtesting broker checks for attached `buy_trading_fees` and `sell_trading_fees` and returns immediately when both are empty, with a performance comment noting that trade fees "are frequently empty in backtests/benchmarks". The `TradingFee` object is capable — flat, percentage and per-contract components, split by maker and taker and applied by order type — but nothing is applied until you build one. Every example that omits it is a frictionless backtest. **No funding, and it is not a subtlety here.** The word does not appear anywhere in the 5,000-line backtesting broker, and the CCXT backtesting source fetches OHLCV only. You can trade Bitunix perpetuals live with leverage; you cannot simulate the eight-hourly cash flow that pays for them. That gap between what the live half can do and what the simulated half models is the sharpest edge on this card. **The crypto backtesting path is documented in one place and missing from two others.** The main backtesting docs table lists Yahoo, ThetaData, Polygon.io, Databento, Pandas, IBKR REST and Polymarket, and routes crypto to Polygon.io; CCXT backtesting appears only on the CCXT broker page. The vendor's own `llms.txt`, generated 2026-09-13, likewise names only Yahoo, Polygon, ThetaData and Polymarket. The code is there and works; the documentation treats it as a side road. **`ai_features` is set to `recommendations` deliberately, and here is what the thing emits.** Lumibot ships a runtime in which an LLM you configure, with a key you supply, is handed tools that place orders inside your trading loop, and the documentation's own showcase is a series of AI trading teams named after living investors — a Warren Buffett value team, a Bill Ackman concentrated team, a Ray Dalio team, a Citadel sector-pods team. Those are demos, the framework itself recommends nothing, and nobody is selling you signals. But an agent that decides and submits is a different object from a rule you wrote, the backtest of an agent is a replay of a cached model run rather than a deterministic simulation, and a demo named after a famous investor invites a reader to treat a prompt as a strategy. Read the agent guide before the marketing. **GPL-3.0, and the package metadata disagrees.** The LICENSE file on the default branch is GPL-3.0 and GitHub's detector reads it the same way; PyPI's metadata for 4.5.91 says MIT. The file is what binds. This is the strictest licence in the category — stricter than the MIT engines beside it — and it means anything you distribute that links this has copyleft obligations. For a strategy you run yourself it changes nothing, and it is exactly the kind of thing a package classifier should not be trusted for. **The vendor sells the hosted version, and the docs know it.** BotSpot is a separate paid platform from the same company — plain-English strategy generation into Lumibot code, hosted backtesting, broker connections, monitoring and kill switches — and the library's own broker and backtesting pages carry sections explaining why it is easier there. Nothing about the library is crippled to create that pressure, and the documentation is genuinely complete. It is worth knowing whose roadmap the library sits on. **Paper trading is the brokers', not the framework's.** The documented paper paths are Interactive Brokers and Alpaca — equity brokers. No crypto paper-trading mode was found, so a crypto strategy goes from a candle backtest to real money with nothing in between. ## Alternatives Choose Lumibot when the strategy is multi-asset and the crypto leg is one of several — it is the only framework in this category that puts a CCXT exchange, an options broker, a futures broker and a prediction market behind one `submit_order` call. That breadth is the product. Choose something else when the strategy is crypto-only and the fills matter. A framework whose crypto backtest is minute candles with no fees by default and no funding model will flatter a high-turnover perpetuals strategy, and the crypto-native engines in [Backtesting & Research Libraries](https://cryptomarkets.tools/categories/backtesting-libraries) model more of what actually happens at the exchange. And if what drew you here was the AI agents, compare it against that on its own terms rather than as a backtester: the question is not whether the framework is good, it is whether an LLM in the trading loop is an idea you want to test with money. ## FAQ ### Which crypto exchanges does Lumibot actually support? Eight documented CCXT paths, at three levels of confidence the vendor publishes itself — Coinbase, Kraken and WEEX auto-detect credentials; KuCoin, Binance and BitMEX need manual CCXT config; Bybit and OKX are listed as backtesting or custom config only. Plus Bitunix for USDT perpetual futures. Anything else in CCXT is untested. ### Is Lumibot MIT or GPL? GPL-3.0. The LICENSE file on the default branch is the GNU General Public License v3 and GitHub's own detector agrees; the PyPI metadata for 4.5.91 says MIT and is wrong. The licence file is the one that binds, and GPL copyleft is a real constraint on anything you intend to distribute. ### What does a Lumibot backtest charge me in fees by default? Nothing. Trading fees and slippage are objects you attach to the strategy, and the backtesting broker returns immediately when none are set. On a daily-turnover crypto strategy that default is the difference between an edge and a mirage, so set TradingFee with your venue's real maker and taker rates before reading any result. ### Does Lumibot ship an MCP server? No. It is an MCP client — external MCP servers can be mounted into a strategy with explicit tool allowlists. The vendor's separate hosted platform, BotSpot, does expose MCP tools, but that is a different product with its own subscription. ### Can I backtest perpetual funding with Lumibot? No. The CCXT backtesting data source fetches OHLCV candles at minute, hour and day granularity and nothing else, and the word funding does not appear anywhere in the backtesting broker. Bitunix perpetuals can be traded live with leverage; the simulation behind that decision has no funding leg. ## Also worth comparing - [Backtesting.py](https://cryptomarkets.tools/tools/backtesting-py.md) — Two thousand lines, one OHLC series, and no idea what a funding payment is. - [Barter](https://cryptomarkets.tools/tools/barter.md) — Rust trading engine and market-data streams — live execution is a trait you implement. - [HftBacktest](https://cryptomarkets.tools/tools/hftbacktest.md) — Tick-by-tick backtesting that models order queue position and feed and order latency. - [LEAN](https://cryptomarkets.tools/tools/lean.md) — The engine behind QuantConnect, Apache-2.0 and runnable on your own machine. - [NautilusTrader](https://cryptomarkets.tools/tools/nautilus-trader.md) — Event-driven Rust engine that settles perpetual funding at the venue boundary. - [Jesse](https://cryptomarkets.tools/tools/jesse.md) — Python backtesting and research framework whose live-trading half is a paid plugin.