Hummingbot is an open-source framework that helps you design and deploy automated trading strategies, or bots, that can run on many centralized or decentralized exchanges. Over the past year, Hummingbot users have generated over $34 billion in trading volume across 140+ unique trading venues.

The Hummingbot codebase is free and publicly available under the Apache 2.0 open-source license. Our mission is to democratize high-frequency trading by creating a global community of algorithmic traders and developers that share knowledge and contribute to the codebase.

Quick Links

• Website and Docs: Official Hummingbot website and documentation
• Installation: Install Hummingbot on various platforms
• Discord: The main gathering spot for the global Hummingbot community
• YouTube: Videos that teach you how to get the most out of Hummingbot
• Twitter: Get the latest announcements about Hummingbot
• Reported Volumes: Reported trading volumes across all Hummingbot instances
• Newsletter: Get our newsletter whenever we ship a new release

Getting Started

Condor (AI harness)

Condor is the AI harness for building and running agentic strategies and bot instances. It connects LLM-powered decision-making to deterministic trade execution via the Hummingbot API, controlled through Telegram or its web dashboard. See condor.hummingbot.org to get started.

hbot CLI

The recommended way to run the Hummingbot client directly is the hbot command-line interface, installed from source. hbot runs, controls, and monitors a trading bot non-interactively: start/stop a bot, author and tune configs, and read trades, PnL, logs, and status — all scriptable, as compact Markdown with stable exit codes. See the hbot CLI guide for the full reference.

Requires Anaconda or Miniconda.

# Clone the repository
git clone https://github.com/hummingbot/hummingbot.git
cd hummingbot

# Create the conda environment, build extensions, and expose the `hbot` CLI
make install

# Activate the environment
conda activate hummingbot
hbot --help

To use hbot outside the conda environment, run make link-cli to add it to your host PATH.

On first use, hbot prompts for a keystore password that encrypts your exchange API keys — set HBOT_PASSWORD or pass --password-stdin to run non-interactively (e.g. in scripts or agent workflows).

Then create a config and run the simple_pmm paper trading script — it simulates trading against live Binance market data, so no API keys are required:

hbot create simple_pmm --name conf_paper_bot.yml \
     --set exchange=binance_paper_trade --set trading_pair=BTC-USDT
hbot start conf_paper_bot.yml                          # run it (one bot per install)
hbot status                                            # check on it
hbot stop                                              # stop gracefully

To trade live, connect your exchange API keys and run a strategy controller like pmm_mister — a reusable V2 strategy whose settings can be tuned live while the bot runs:

hbot connect binance                                   # store API keys (encrypted)
hbot create pmm_mister --name conf_my_bot.yml \
     --set connector_name=binance --set trading_pair=BTC-USDT --set total_amount_quote=100
hbot start conf_my_bot.yml                             # run it (one bot per install)

Full command reference and ontology: hbot CLI guide.

Docker

Prefer containers? hbot works the same way — install Docker Compose, then:

git clone https://github.com/hummingbot/hummingbot.git
cd hummingbot
make setup            # answer `y` to "Include Gateway?" to add the DEX middleware
make deploy           # start the container (interactive client by default)
make link-cli         # put the `hbot` command on your host PATH (dispatches into the container)

hbot --help           # same commands as the source install above

make link-cli installs a small wrapper that runs hbot inside the container, so every command above is identical whether you installed from source or Docker. (Or skip it and use docker exec -it hummingbot hbot .) To dedicate the container to hbot instead of the interactive client, uncomment command: tail -f /dev/null in docker-compose.yml before make deploy — see Running in Docker.

Interactive Client (TUI)

The classic full-screen client is the Docker default: make deploy, then docker attach hummingbot — or run it from source with make install && make run. With Gateway included it starts in development mode (unencrypted HTTP); for production HTTPS use the DEV=false flag and run gateway generate-certs. See Development vs Production Modes.

For comprehensive installation instructions and troubleshooting, visit our Installation documentation.

Strategies

Hummingbot offers several frameworks for building and running algorithmic trading strategies — see the Strategies docs for a full overview:

• Scripts: Single-file Python strategies — the easiest way to build and customize your own bot. Example: simple_pmm.py, a basic market making script.
• Controllers: Reusable V2 strategies whose configs can be backtested, deployed, and tuned live while running. Example: pmm_mister.py, a full-featured market making controller.
• Executors: Self-contained building blocks that manage order lifecycles for common patterns — position, DCA, grid, arbitrage, XEMM, TWAP, and LP. Example: position_executor, which manages a directional position with triple-barrier risk controls.
• V1 Strategies: Classic legacy strategies such as Pure Market Making, Avellaneda Market Making, and Cross-Exchange Market Making. Example: cross_exchange_market_making, which market makes on one exchange and hedges fills on another.

Exchange Connectors

Hummingbot connectors standardize REST and WebSocket API interfaces to different types of exchanges, enabling you to build sophisticated trading strategies that can be deployed across many exchanges with minimal changes.

Connector Types

We classify exchange connectors into three main categories:

• CLOB CEX: Centralized exchanges with central limit order books that take custody of your funds. Connect via API keys.

  • Spot: Trading spot markets
  • Perpetual: Trading perpetual futures markets

• CLOB DEX: Decentralized exchanges with on-chain central limit order books. Non-custodial, connect via wallet keys.

  • Spot: Trading spot markets on-chain
  • Perpetual: Trading perpetual futures on-chain

• AMM DEX: Decentralized exchanges using Automated Market Maker protocols. Non-custodial, connect via Gateway middleware.

  • Router: DEX aggregators that find optimal swap routes
  • AMM: Traditional constant product (x*y=k) pools
  • CLMM: Concentrated Liquidity Market Maker pools with custom price ranges

Exchange Sponsors

We are grateful for the following exchanges that support the development and maintenance of Hummingbot via broker partnerships and sponsorships.