Hummingbot Integration for Market Making and Algorithmic Trading
You launched Hummingbot with Pure Market Making, and a week later your PnL is down 15%? The cause is inventory skew — accumulation of the base asset during trend moves. We have integrated Hummingbot for 20+ projects, from startups to prop trading firms, and know how to avoid typical mistakes. In this article, we'll discuss configuration, custom scripts, and risk control.
Hummingbot is an open source framework for market making and liquidity strategies, described in the official documentation. Unlike Backtrader or Freqtrade, Hummingbot is built for bid-ask spread: placing two-sided quotes and managing inventory. It supports 40+ exchanges (CEX and DEX). Based on our data, Hummingbot provides 30% less inventory skew compared to Freqtrade under the same market conditions. Average commission savings at $1M monthly volume are around $1500.
Strategies for Market Making
| Strategy | Profit Source | Main Risk | Typical Spread in ETH/USDT |
|---|---|---|---|
| Pure Market Making | Bid-ask spread minus fees | Inventory skew during directional moves | 0.06-0.15% |
| Cross-Exchange Market Making | Spread between exchanges minus hedge cost | Slippage when hedging | 0.03-0.08% |
| Perpetual Market Making | Spread + funding rate | Liquidation during strong moves | 0.04-0.12% |
| AMM Arbitrage | Arbitrage between DEX and CEX | Gas cost and slippage | 0.01-0.05% |
The table shows: Pure Market Making offers the largest spread but requires strict inventory control. Cross-Exchange is safer but more complex to set up.
Why Inventory Control Matters
The main risk of market making is accumulating inventory in one direction during a directional market move. For example, in the BTC-USDT pair when price rises, the bot sells base asset (BTC) and accumulates USDT. If you don't adjust the spread in time, the inventory ratio can reach 80% in base asset, and a correction will cause losses due to depreciation.
We use a script with dynamic spread shift based on inventory ratio. Here's an example:
class InventoryAwareMarketMaker(ScriptStrategyBase):
target_base_pct = Decimal("0.5") # target 50% in base asset
max_shift_spread = Decimal("0.003") # maximum spread shift
def on_tick(self):
# Calculate current inventory ratio
balances = self.connectors[self.exchange].get_all_balances()
base_balance = balances.get("BTC", Decimal(0))
quote_balance = balances.get("USDT", Decimal(0))
mid_price = self.connectors[self.exchange].get_mid_price(self.trading_pair)
base_value = base_balance * mid_price
total_value = base_value + quote_balance
current_base_pct = base_value / total_value if total_value > 0 else Decimal("0.5")
# Shift spread to restore balance
inventory_skew = current_base_pct - self.target_base_pct
shift = inventory_skew * self.max_shift_spread * 2
# If too much base, shift prices down (stimulate sells)
bid_spread = self.base_spread - shift
ask_spread = self.base_spread - shift # lower ask price = more sells
This approach reduced inventory skew in one of our projects from 35% to 8% in 2 days. The key parameter is target_base_pct: for high-volatility pairs set 45%, for stable ones 55%.
How to Install Hummingbot
The recommended method is via Docker. Clone the repository and run the container:
git clone https://github.com/hummingbot/hummingbot.git cd hummingbot docker compose up -d Docker build ensures configuration reproducibility.
Alternative installation via pip
Install via pip: pip install hummingbot, but dependency issues may arise on Windows. We recommend using a virtual environment.
How to Write a Custom Strategy
from hummingbot.strategy.script_strategy_base import ScriptStrategyBase
from hummingbot.core.data_type.common import OrderType, TradeType
from decimal import Decimal
class SimpleMarketMaker(ScriptStrategyBase):
"""Simple market maker with fixed spread"""
trading_pair = "BTC-USDT"
exchange = "binance"
# Parameters
bid_spread = Decimal("0.001") # 0.1% below mid-price
ask_spread = Decimal("0.001") # 0.1% above mid-price
order_amount = Decimal("0.001") # BTC per side
refresh_time = 30 # seconds
markets = {exchange: {trading_pair}}
def on_tick(self):
if self.current_timestamp - self.last_refresh < self.refresh_time:
return
self.cancel_all_orders()
mid_price = self.connectors[self.exchange].get_mid_price(self.trading_pair)
if not mid_price:
return
bid_price = mid_price * (1 - self.bid_spread)
ask_price = mid_price * (1 + self.ask_spread)
self.buy(
connector_name=self.exchange,
trading_pair=self.trading_pair,
amount=self.order_amount,
order_type=OrderType.LIMIT,
price=bid_price,
)
self.sell(
connector_name=self.exchange,
trading_pair=self.trading_pair,
amount=self.order_amount,
order_type=OrderType.LIMIT,
price=ask_price,
)
self.last_refresh = self.current_timestamp
"}This script is a base. For production, add inventory control, timeout, and error logging.
How to Configure Strategy via YAML
# conf/strategies/pure_market_making.yml
strategy: pure_market_making
exchange: binance
market: BTC-USDT
bid_spread: 0.1 # %
ask_spread: 0.1 # %
minimum_spread: -100 # allow negative spread
order_refresh_time: 30 # seconds
max_order_age: 1800 # 30 minutes
order_amount: 0.001
filled_order_delay: 60
inventory_skew_enabled: true
inventory_target_base_pct: 50
inventory_range_multiplier: 1.0
What's Included in Hummingbot Integration
- Analysis of trading scenario and strategy selection.
- Installation and infrastructure configuration (Docker, server).
- Writing custom scripts for your parameters.
- Exchange integration (API keys, IP whitelist).
- Backtesting on historical data and sandbox testing.
- Team training and documentation.
Timeline depends on strategy complexity: from 1 day for basic Pure Market Making setup to 3 days for custom scripts with Cross-Exchange and hedging.
Typical Errors When Integrating Hummingbot
| Error | Consequence | Solution |
|---|---|---|
| Ignoring inventory skew | Excess inventory accumulation | Use dynamic spread shift |
| Incorrect target_base_pct | Losses during trends | 40-45% for volatile pairs, 50% for stable |
| Missing stop-loss | Large losses during moves >5% | Cancel orders and fix position |
| Too frequent refresh | Excessive fees | Increase order_refresh_time to 60 seconds |
In one project, we found that a bot with refresh_time=15 on ETH-USDT placed 200 orders per minute, eating all profit at 0.1% fee. After setting refresh_time=60, the spread held and fees dropped by 60%.
Hummingbot is the de facto standard for crypto market making in the open source space. Our engineers are Hummingbot certified and will help configure a strategy for your risk profile. Contact us for a consultation — we will analyze the market and suggest the optimal configuration. Order Hummingbot integration and your profit will no longer depend on chance.