Skip to main content

Best open-source crypto trading bots, and where each one falls short

Open-source trading bots give you the code, the backtester, and the exchange connectors for free. They do not give you a strategy, a server, an on-call rotation, or anyone to blame. Whether that trade is a good one depends entirely on which of those you wanted.

The projects below are mature, actively maintained, and used by real traders. Each has a reason to exist and a specific gap it leaves for you to fill. The gap is the useful part of the review, because the feature lists are all long and the gaps are what decide whether the bot makes you money or costs you a weekend.

This page compares the main options on what they ship and what they leave out, then covers the three shortfalls every open-source bot shares and what the alternatives to filling them yourself look like.

Key takeaways​

  • Four projects cover most of the field: Freqtrade for strategy development, Hummingbot for market-making and arbitrage, OctoBot for a friendlier all-rounder, Jesse for research-first backtesting. CCXT is the library underneath several of them, not a bot.
  • None ships a profitable strategy. The strategy is the product, and it is yours to write.
  • The three shared gaps are operations, risk management, and custody. The bot runs on your machine, enforces only the risk rules you coded, and trades an exchange account it holds keys to.
  • Open source is the right choice when you want to own the strategy. It is the wrong choice when you wanted the outcome without the work.

How the projects compare​

BotLanguageBuilt forShips withExchangesWhere it falls short
FreqtradePythonStrategy development and backtestingBacktester, hyperparameter optimisation, FreqAI machine-learning module, Telegram control, web UIMany spot and some futures venues via CCXTNo strategy included; ops and risk are yours
HummingbotPythonMarket making and arbitrageMarket-making and arbitrage strategy templates, including funding-rate arbitrage; CEX and DEX connectorsWide CEX coverage plus DEX connectorsStrategies are templates; inventory and venue risk are yours
OctoBotPythonAccessible all-rounderWeb interface, strategy and evaluator modules ("tentacles"), backtesting, optional hosted cloudMajor CEXs via CCXTLess depth than Freqtrade for research; cloud option reintroduces a host
JessePythonResearch-first quant workflowsClean backtesting API, indicators, optimisation, live tradingFewer venues than the othersSmaller ecosystem; live trading is the second priority
CCXTJS, Python, PHPExchange connectivityUnified API to 100+ exchangesAlmost everythingIt is a library. There is no bot until you write one

Details are drawn from each project's public documentation at last review. Confirm current exchange support and features before relying on them.

1. Freqtrade: the strategy developer's bot​

Freqtrade is the most complete open-source framework for writing, testing, and running your own strategy. You define entry and exit logic in a Python class, backtest it against downloaded data, optimise parameters with its hyperopt tool, and run it live with Telegram or web-UI control. FreqAI adds a machine-learning pipeline for people who want to train models on features they define.

Where it falls short is exactly where its documentation is honest: it ships no profitable strategy, and the example strategies are for learning the framework. Everything Freqtrade does well is downstream of a strategy you have to have. It also expects you to run it, on a VPS or a machine that stays on, with exchange API keys stored on that machine.

Choose it if you want to develop strategies seriously and own every line. Skip it if you wanted a bot that trades.

2. Hummingbot: market making and arbitrage​

Hummingbot is built for the strategies that need continuous quoting or multi-venue legs: market making, cross-exchange arbitrage, and funding-rate arbitrage. It ships those as configurable controllers rather than as a blank strategy class, and its connector list includes decentralized venues, which most bots ignore.

It falls short in the ways market-making does. Running quotes means holding inventory, and the bot does not protect you from a move that leaves you full of the wrong asset. Cross-venue strategies require capital on several exchanges and expose you to each one. The funding-rate arbitrage controller runs the hedged trade, but margin management during a squeeze is still your configuration and your problem.

Choose it if your strategy is a market-structure one rather than a signal one. The delta-neutral bots page places it against agents and exchange bots that run the same funding trade.

3. OctoBot: the all-rounder with a web UI​

OctoBot trades off some depth for accessibility. Its web interface, modular strategy system, and backtesting make it the easiest of the four to get running, and it offers a hosted cloud version for people who do not want to self-host.

It falls short for research-heavy users, who will hit Freqtrade's larger toolset sooner, and the cloud option reintroduces exactly the dependency that open source was supposed to remove: a company hosting your bot and holding your keys.

Choose it if you want an open-source bot with a gentler start. The cloud option is a separate decision with a separate custody answer.

4. Jesse: backtesting first​

Jesse is a quant researcher's framework with a clean strategy API and a strong backtester, with live trading available but secondary. Its ecosystem is smaller, and it supports fewer venues.

It falls short as a production bot, and it does not claim otherwise. Choose it for research and strategy development; move to another framework or your own code for live execution if you outgrow it.

CCXT: the library everyone forgets is not a bot​

CCXT gives you one API across more than a hundred exchanges. Freqtrade and OctoBot use it underneath. It is essential and it is not a bot: with CCXT alone, you have market data and order placement and nothing else.

If you find yourself building a loop around CCXT, you are writing a bot. That is fine, and the frameworks above are what that loop becomes after a year.

The three gaps every open-source bot leaves​

These are shared across all four projects, and no amount of feature comparison changes them.

Operations. The bot runs where you run it. If the server reboots, the exchange changes an API, or your network drops during a move, the position stays open with nobody watching. Serious users run monitoring, alerts, and a second machine. That is infrastructure work, and it is the part of "free" that costs the most.

Risk management. The bot enforces the risk rules you coded and no others. Position sizing, drawdown limits, kill switches, and margin checks exist if you wrote them. A backtested strategy with no live risk layer is the most common way an open-source bot loses more than it was supposed to.

Custody. The bot trades an exchange account through API keys stored on your machine. Trade-only permissions stop it withdrawing, but the funds remain on the exchange, and the keys remain on a server you have to secure. For a DEX-connected bot, the wallet key on the server is the same problem in a different form.

None of these are defects in the software. They are the responsibilities the software correctly leaves with you.

When the alternative is not a bot at all​

If what you wanted was the outcome of a strategy rather than the ownership of one, an open-source bot is the wrong tool, and the shortfalls above are the reason.

Two other models exist. Configurable SaaS bots such as 3Commas or Cryptohopper host the bot for you and connect to your exchange account; the 3Commas comparison covers that trade. Curated agents run a defined strategy for you from a wallet you control; Deploy Finance's Income: Funding Rates runs a hedged funding trade on Hyperliquid with a session key that can trade and cannot withdraw, and its Superstar agent runs a directional strategy. In both, the operations, risk layer, and permission scope are the provider's responsibility rather than yours, and the strategy is theirs rather than yours.

That is the trade in reverse. Open source gives you the strategy and the burden; an agent gives you neither.

Verdict​

Freqtrade if you are developing strategies and want the deepest toolset. Hummingbot if your edge is market structure: making, arbitrage, or funding capture. OctoBot if you want an easier start and accept less depth. Jesse for research. CCXT when you are building your own.

All four assume you will write the strategy, run the server, code the risk layer, and secure the keys. If that is the work you wanted, they are excellent. If it is not, the shortfall is not in the software.

Learn more​

Start with Deploy Finance​

Create a self-custodial Deploy Finance wallet and review the live agents.