A practical guide to open source crypto grid bots — how they work, which free projects are worth running, and how to build your own with Python for Binance, Bybit, and OKX.
Grid trading is one of the most battle-tested strategies in crypto — and for good reason. It doesn't require you to predict market direction. It profits from volatility by placing buy and sell orders at regular intervals across a price range. When the market oscillates within that range, the bot collects the spread on every swing, automatically, around the clock. The open source community has built solid, production-tested grid bots you can inspect, modify, and deploy on your own infrastructure — no subscription fees, no black boxes. Whether you're trading on Binance, Bybit, or OKX, there's a free option worth considering.
A grid bot divides a price range into evenly spaced levels — your grid lines. It places a buy order at each level below the current price and a sell order at each level above it. When price drops to a buy level, the order executes and the bot immediately places a sell order one grid level higher. When that sell fills, the bot pockets the spread and resets. This cycle repeats indefinitely while price stays within the range.
The math is simple. Set a grid from $60,000 to $65,000 on BTC with 10 levels and you get $500 spacing. Buy at $60,000, sell at $60,500. Buy at $60,500, sell at $61,000. Each filled pair earns you the grid spread minus fees. With tight enough spreads and enough oscillation, this compounds quietly.
Grid bots thrive in sideways or mildly oscillating markets. Where they struggle is during strong directional breakouts — if BTC breaks cleanly above your upper bound, the bot is left holding cash while the asset rallies without you. Conversely, if price crashes through the floor, the bot keeps accumulating a losing position. Understanding when NOT to run a grid bot matters as much as knowing how to configure one.
Not every open source bot is worth your time. Here are the ones that have actually earned their reputation.
Hummingbot is the most mature open source market-making and grid trading framework available. It supports Binance, Bybit, OKX, Coinbase, KuCoin, Gate.io, and dozens of other exchanges through modular connector plugins. Written in Python, it includes a pure market-making strategy that functions as a robust grid bot, plus a dedicated AMM arbitrage module. The community is active, documentation is solid, and updates ship regularly. The learning curve is steeper than a turnkey SaaS, but you get full strategy control and zero platform fees.
Freqtrade is primarily a backtesting and trend-following framework, but it supports custom strategy classes that can implement grid-like logic. Its backtesting engine is best-in-class for open source tools, Docker deployment is well-documented, and it has a native Telegram integration for trade notifications. If strategy research and historical validation matter to you, Freqtrade's tooling is hard to beat.
Jesse is a newer Python framework with a clean API, good documentation, and support for Binance and Bybit. It's a strong choice if you want to build a custom grid strategy from scratch with proper backtesting and minimal boilerplate. Gekko — once the dominant open source bot — is now archived and unmaintained. Don't build new infrastructure on it.
| Project | Exchanges | Native Grid | Backtesting | Status |
|---|---|---|---|---|
| Hummingbot | Binance, Bybit, OKX, KuCoin, Gate.io, Coinbase | Yes | Limited | Active |
| Freqtrade | Binance, Bybit, Coinbase | Via custom strategy | Excellent | Active |
| Jesse | Binance, Bybit | Via custom strategy | Good | Active |
| Gekko | Multiple | Yes | Basic | Archived |
If you want full transparency into what your bot does with your money — and serious traders eventually always do — building one yourself is the cleanest path. Below is a minimal but functional grid bot skeleton covering configuration, level generation, and order management.
Start with the configuration and grid level calculation:
from dataclasses import dataclass
from decimal import Decimal
@dataclass
class GridConfig:
symbol: str # e.g. "BTCUSDT"
lower_price: Decimal # grid floor
upper_price: Decimal # grid ceiling
grid_count: int # number of levels
total_investment: Decimal # USDT to deploy
@property
def grid_spacing(self) -> Decimal:
return (self.upper_price - self.lower_price) / self.grid_count
@property
def order_size_usdt(self) -> Decimal:
# Equal USDT allocation per grid level
return self.total_investment / self.grid_count
def calculate_grid_levels(config: GridConfig) -> list[Decimal]:
"""Generate all price levels for the grid."""
levels = []
for i in range(config.grid_count + 1):
price = config.lower_price + (config.grid_spacing * i)
levels.append(price.quantize(Decimal("0.01")))
return levels
# Example: BTC grid between $60k and $65k with $500 spacing
config = GridConfig(
symbol="BTCUSDT",
lower_price=Decimal("60000"),
upper_price=Decimal("65000"),
grid_count=10,
total_investment=Decimal("1000")
)
levels = calculate_grid_levels(config)
print(f"Grid spacing: ${config.grid_spacing}")
print(f"Order size per level: ${config.order_size_usdt}")
print(f"Levels: {levels}")Now the core order management logic that fires when an order fills and places the counter-order:
class GridBot:
def __init__(self, config: GridConfig, exchange_client):
self.config = config
self.client = exchange_client
self.active_orders: dict[Decimal, str] = {} # price -> order_id
def initialize_grid(self, current_price: Decimal):
"""Place initial buy/sell orders relative to current price."""
levels = calculate_grid_levels(self.config)
for level in levels:
qty = float(self.config.order_size_usdt / level)
if level < current_price:
order = self.client.place_limit_order(
symbol=self.config.symbol,
side="BUY",
price=float(level),
quantity=round(qty, 6)
)
self.active_orders[level] = order["orderId"]
print(f"[INIT] BUY @ {level}")
elif level > current_price:
order = self.client.place_limit_order(
symbol=self.config.symbol,
side="SELL",
price=float(level),
quantity=round(qty, 6)
)
self.active_orders[level] = order["orderId"]
print(f"[INIT] SELL @ {level}")
def on_order_filled(self, filled_price: Decimal, side: str):
"""React to a fill by placing the counter-order one grid away."""
spacing = self.config.grid_spacing
if side == "BUY":
counter_price = filled_price + spacing
counter_side = "SELL"
else:
counter_price = filled_price - spacing
counter_side = "BUY"
# Validate counter price stays within grid range
if not (self.config.lower_price <= counter_price <= self.config.upper_price):
print(f"Counter price {counter_price} outside grid range — skipping")
return
qty = float(self.config.order_size_usdt / counter_price)
order = self.client.place_limit_order(
symbol=self.config.symbol,
side=counter_side,
price=float(counter_price),
quantity=round(qty, 6)
)
print(f"[FILL] {side} @ {filled_price} → {counter_side} @ {counter_price}")
self.active_orders[counter_price] = order["orderId"]All three major exchanges offer official Python SDKs with similar structures for limit order placement. Here's a working Binance connection with error handling:
from binance.client import Client
from binance.exceptions import BinanceAPIException
import os
def create_binance_client() -> Client:
api_key = os.environ["BINANCE_API_KEY"]
api_secret = os.environ["BINANCE_API_SECRET"]
return Client(api_key, api_secret)
def place_limit_order(client: Client, symbol: str, side: str,
price: float, quantity: float) -> dict:
try:
return client.create_order(
symbol=symbol,
side=side,
type="LIMIT",
timeInForce="GTC", # Good Till Cancelled
quantity=quantity,
price=str(round(price, 2))
)
except BinanceAPIException as e:
print(f"Order rejected [{e.status_code}]: {e.message}")
raise
# Wire everything together
client = create_binance_client()
bot_config = GridConfig(
symbol="BTCUSDT",
lower_price=Decimal("60000"),
upper_price=Decimal("65000"),
grid_count=10,
total_investment=Decimal("500")
)
# Adapter so GridBot can call client.place_limit_order uniformly
class BinanceAdapter:
def __init__(self, client: Client):
self.client = client
def place_limit_order(self, symbol, side, price, quantity):
return place_limit_order(self.client, symbol, side, price, quantity)
bot = GridBot(bot_config, BinanceAdapter(client))
ticker = client.get_symbol_ticker(symbol="BTCUSDT")
current_price = Decimal(ticker["price"])
bot.initialize_grid(current_price)Binance enforces weight-based API rate limits — a single order counts as 1 weight, but initializing a 20-level grid fires 20 requests in quick succession. Add a small delay between orders (time.sleep(0.1)) to stay within the 1200 weight-per-minute limit. Bybit and OKX have similar per-second caps. Exceeding them gets your API key temporarily banned, not your account — but it will interrupt bot operation.
On Bybit, the equivalent SDK is pybit — the method signatures are nearly identical, using place_order() with category='spot' or category='linear' for perpetuals. OKX's official Python SDK uses trade_api.place_order() with instType set to 'SPOT' or 'SWAP'. The grid logic above is exchange-agnostic once you wrap the client in an adapter class as shown.
Yes — in virtually every major jurisdiction, running a crypto trading bot is completely legal. Automated trading is explicitly supported by all the major exchanges. Binance, Bybit, OKX, Coinbase, KuCoin, and Gate.io all publish APIs specifically designed for programmatic order placement. Institutional market makers run bots at scale on these same platforms.
What can cross legal lines is a narrower set of behaviors. Market manipulation — wash trading, spoofing fake orders, layering — is illegal in regulated markets and increasingly enforced in crypto. Running automated orders on a platform that explicitly prohibits bots in its Terms of Service can get your account suspended, though most major exchanges do not prohibit bots. Trading tokens classified as unregistered securities is a jurisdiction-specific risk that has nothing to do with automation itself.
The crypto trading bots legal question comes up often from newer traders. The short answer: if you're running a standard grid bot on BTC/USDT or ETH/USDT spot markets on Binance or Bybit, you have nothing to worry about legally. Thousands of retail traders do exactly this daily.
The answer depends on your technical comfort level and what you're optimizing for.
If you want a polished UI with zero code: Pionex offers a built-in free grid bot that runs natively on its exchange infrastructure. No deployment required. The tradeoff is you're trusting Pionex with your funds and have no control over the strategy logic. 3Commas has a free tier as well, though the most useful features are behind a paywall.
If you want open source with production reliability: Hummingbot is the strongest option. It's not beginner-friendly — expect to spend a few hours on setup — but it's battle-tested, actively maintained, and supports Binance, Bybit, OKX, KuCoin, Gate.io, and more. You own your keys and your infrastructure.
If you want to learn while building: write your own bot using the code structure above. You'll understand every trade your bot makes, which is invaluable when it starts behaving unexpectedly at 2am.
One practical edge worth considering: VoiceOfChain provides real-time signals across crypto pairs that can inform when and where to deploy a grid bot. Grid bots perform best on pairs that are consolidating rather than trending — using signal data to identify low-momentum, range-bound pairs before setting up a grid is a meaningful improvement over picking pairs at random.
Open source grid bots give you something proprietary platforms never will: full transparency into what happens with your capital. Whether you choose Hummingbot for its production polish, Freqtrade for its backtesting depth, or build a custom Python bot from scratch — the underlying strategy is sound and the tooling has never been more accessible. The real edge isn't in the software. It's in understanding the mechanics deeply enough to pick the right pairs, set ranges backed by data, and respect stop losses when the market breaks out of your assumptions. Pair a well-configured grid with real-time signal intelligence from a platform like VoiceOfChain and you have a systematic, research-backed approach that compounds quietly while you focus elsewhere.