# Freqtrade Write the strategy in Python, backtest it, then run the same class live. *https://cryptomarkets.tools/tools/freqtrade · Backtesting & Research Libraries* ## Facts ### At a glance | Field | Value | | --- | --- | | Vendor | Freqtrade | | Category | Backtesting & Research Libraries | | Job | live_trading | | Website | https://www.freqtrade.io/en/stable/ | | 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-21 | ### Coverage | Field | Value | | --- | --- | | Asset classes | spot, perpetuals | | Chains | none | | Venues | cex, dex, derivatives | | Data latency | realtime | | Platforms | cli, web | | AI features | research | ### Interfaces | Field | Value | | --- | --- | | API | true | | Webhooks | true | | Scripting | Python | | MCP server | false | | Export | json, parquet, api | ### Capabilities Yes: charting, screening, backtesting, automation, live_trading, paper_trading, alerts No: 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 program you run yourself that trades a strategy you wrote. The strategy is a class operating on a pandas dataframe, and the same class is what the backtester runs, what dry-run mode runs and what trades live — there is no second implementation to keep in sync, which is the main reason to pick a framework like this over a backtest library plus your own execution code. It is a command-line application first. A REST API server, a web UI (FreqUI) and a Telegram bot are the three ways to watch and control a running instance; none of them is where you write the strategy. Requirements are Python 3.11+ and TA-Lib, or Docker, which the project recommends instead. The documented hardware floor is 2 GB RAM, 1 GB of disk and 2 vCPU. The licence in the repository is GPL-3.0 — the LICENSE file itself, not only the badge and the packaging classifier, which agree with it here. Copyleft matters if you intend to distribute a modified bot; running a private strategy on your own server obliges you to publish nothing. Liveness, in dates rather than adjectives, as of 19 September 2026: the last commit on the default `develop` branch was that morning, release 2026.8 landed on 31 August 2026 — one release a month, unbroken from May to August in the releases feed — and the repository is not archived. Open issues stand at 22, with 7 open pull requests alongside them — worth separating, because the count GitHub's API reports adds the two together. ## Pricing Free, and unusually for this category there is nothing adjacent for sale either — no hosted runner, no signal subscription, no commercial licence, no token. FreqAI, the machine-learning module, states in the documentation that it is not-for-profit, sells no signals and has no token of its own. Your costs are a server and exchange fees. Freqtrade does not add a commission and does not route orders through anything of its own — it holds your exchange API keys and calls the exchange directly. ## Data & coverage Freqtrade ships no data. Candles come from the exchange you are trading, fetched through ccxt and stored locally by `freqtrade download-data`; the default on-disk format is Apache Arrow feather, with json, gzipped json and parquet available instead. That means your history is only as deep as the venue's own API goes, and the venue quirks below are yours to work around. Spot support is listed for Binance, BingX, Bitget, Bybit, Bybit EU, Gate, Gate EU, HTX, Hyperliquid, Kraken, MyOKX and OKX; futures for Binance, Bitget, Bybit, Gate, Hyperliquid, Kraken and OKX. Bitvavo and KuCoin are marked as community-tested rather than supported. Everything else ccxt can reach is explicitly "we cannot guarantee they will work", which is a more honest sentence than the exchange counts most frameworks in this category advertise — those counts are usually ccxt's list, not the framework's. Futures here means perpetual swaps. In that mode the downloader pulls mark and funding-rate candles automatically, so funding payments and liquidation prices are part of the simulation rather than an afterthought, and a `liquidation_buffer` (default 0.05) keeps the stop above the liquidation price. Live data arrives over websockets through ccxt.pro where the exchange supports it — `exchange.enable_ws` defaults to true — and falls back to REST polling when the socket fails or is switched off. Pair selection is dynamic: pairlist handlers build the traded universe from volume, market cap, percentage change, age, volatility, spread, price precision or a remote list, with blacklists on top. ## Integrations Control and monitoring run over a Telegram bot, a REST API with an OpenAPI interface and a message websocket, and FreqUI, the project's own web front end, installed with `freqtrade install-ui`. Webhooks post bot events to any endpoint you point them at. A producer/consumer mode lets one instance compute signals that a fleet of others consume. FreqAI is part of the same repository rather than a separate product: it retrains a model during a live run, builds feature sets from your strategy, and plugs into any Python ML library, with eight example models shipped. It emits predictions for your strategy to act on; it does not tell you what to trade. Charts are FreqUI's job, with a plot configurator that can load the `plot_config` from your strategy. The older CLI plotting commands still exist but are documented as deprecated and in maintenance mode. ## Limitations **The default fill model is optimistic and the docs say so.** Orders fill at the requested price with no slippage as long as that price sits inside the candle's high-low range, entries happen at the candle open, and exit signals fill at the next candle's open. Fees are better handled than in most engines — the exchange's own maker/taker fee is read from market info by default rather than assumed to be zero — but intra-candle movement is guesswork unless you pass `--timeframe-detail` with a faster timeframe, which costs memory and runtime and needs that data downloaded too. **Backtests and live runs do not select pairs the same way.** The automatic pairlists are not available in backtesting, so a backtest runs on a static list while the live bot re-picks its universe. The comparison you are making is therefore not quite like for like. **Margin trading is documented as currently unavailable.** You get spot and perpetual futures. Dated futures and options are not supported at all, and shorting requires futures mode. **Leverage assumes the account is yours alone.** Two bots cannot share one leveraged account because liquidation levels are computed on that assumption, and the docs warn that cross-margin's cross-position effects may not be fully simulated in dry-run or backtesting. Liquidation prices are computed but liquidation *fees* are not tracked at all, which the docs say makes the profit and loss inaccurate for any run that actually gets liquidated. **Three venue-specific holes worth knowing before you pick an exchange.** Hyperliquid returns no historical data, so a venue you can trade live cannot be backtested. Kraken requires `--dl-trades` to download trades and rebuild candles, otherwise you get the same 720 candles repeatedly. OKX only provides mark candles for roughly the last three months, so funding fees before that window cannot be computed correctly. **Historic exchange trading limits are not available.** Minimum stake sizes are checked against today's limits applied to a historic price, which can inflate the minimum amount above $50 in a backtest and reject trades that would have been fine. **It ships no edge.** The repository's example strategies exist to show the API, and the documentation opens with a disclaimer that the software is for educational purposes. The questions on the [backtesting and research](https://cryptomarkets.tools/categories/backtesting-libraries) page — fees, slippage, lookahead — are yours to get right inside your own strategy code. ## Alternatives [OctoBot](https://cryptomarkets.tools/tools/octobot) is the same idea for people who would rather configure than write Python, and its backtester is the weaker half — one constant funding rate for a whole run, no slippage model, zero simulated fees by default. [Hummingbot](https://cryptomarkets.tools/tools/hummingbot) overlaps on automation and is far deeper on market making, with a backtester that is weaker still. [Jesse](https://cryptomarkets.tools/tools/jesse) is research-first and charges for the live half as a one-time plugin, which is the opposite bargain to this one. [NautilusTrader](https://cryptomarkets.tools/tools/nautilus-trader) is the heavier engineering answer — an event-driven core where the same strategy backtests and trades live — and its defaults need reading too, since liquidation is off until you turn it on. If what you want is the fill model rather than the bot, [hftbacktest](https://cryptomarkets.tools/tools/hftbacktest) models queue position and latency, and nothing here does. ## FAQ ### Is Freqtrade free? Yes, and there is nothing to buy — no hosted tier, no paid licence, no token. The licence in the repository is GPL-3.0. What it costs you is a server to run it on and the trading fees your exchange charges. ### Which exchanges does Freqtrade support for futures? The documentation lists seven for futures — Binance, Bitget, Bybit, Gate, Hyperliquid, Kraken and OKX — and twelve entries for spot, counting regional variants such as Bybit EU and MyOKX separately. Anything else reachable through ccxt is explicitly not guaranteed to work. ### Can I backtest a Hyperliquid strategy in Freqtrade? No. The docs state that the Hyperliquid API returns nothing beyond current data, so historical downloads are not possible for that venue. You can trade it live and dry-run it, but the backtest has no candles to run against. ### Does Freqtrade model funding payments on perpetuals? Yes. In futures mode it downloads mark and funding_rate candles alongside the usual OHLCV, so funding is part of the simulated result rather than something you add afterwards. ## 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. - [Lumibot](https://cryptomarkets.tools/tools/lumibot.md) — One Python strategy that backtests and then trades live, across eight CCXT exchanges. - [NautilusTrader](https://cryptomarkets.tools/tools/nautilus-trader.md) — Event-driven Rust engine that settles perpetual funding at the venue boundary. ## Named as a replacement for - [Enigma Catalyst](https://cryptomarkets.tools/alternatives/enigma-catalyst.md) - [Gekko](https://cryptomarkets.tools/alternatives/gekko.md)