Grid Trading in Crypto Explained: How Grid Bots Work and Their Risks

Grid trading ladders limit orders at fixed intervals and harvests the oscillation between them. For a professional, the marketing ("profit from volatility, no prediction needed") obscures the actual exposure: a grid is a short-gamma, short-realized-volatility position with a concave payoff, financed by accumulating directional inventory against the move. It is, in payoff terms, close to a discretized short straddle with no premium collected up front. Understanding it as a short-vol inventory bet — not a "set-and-forget money machine" — is the entire point.

The mechanical edge per cycle is the grid spacing minus fees; the risk is the mark-to-market on inventory you are forced to hold when price leaves the box. Those two are not symmetric, which is why the smooth equity curve hides a fat left tail.

The payoff: why a grid is short gamma

Each rung pair is a buy-low/sell-high round trip. As price oscillates, you book spacing repeatedly — a steady positive drip, like collecting variance risk premium on the short side. But the position is long as price falls and short as price rises (you buy into declines, sell into rallies). That is precisely a negative-gamma profile: your inventory grows in the losing direction. Realized PnL of an arithmetic grid as price moves from the center to some terminal level is approximately:

grid_pnl ≈ (cycles_completed * spacing)              # mean-reverting income
         - (inventory_held * adverse_displacement)   # mark-to-market on trapped inventory
         - (total_fills * fee_per_fill)              # frictions

When price round-trips, the first term dominates and grids look brilliant. When price trends, the second term — quadratic-ish in displacement because both the inventory and the distance grow — overwhelms everything. This is the same "pennies in front of a steamroller" structure as naked short options, and it has no positive expected value unless realized volatility is range-bound relative to the implied move you are effectively short.

There is no free lunch — what you are actually paid for

A grid earns the bid-offer spread at discrete levels without continuous requoting. That is a frozen, low-frequency market-making posture, and it inherits market making's core risk — adverse selection — without market making's defenses (real-time inventory management, hedging, requote speed). A real maker flattens inventory continuously; a grid bot warehouses it indefinitely. So the honest statement is: a grid has no alpha; it is a bet that future realized volatility stays inside a box, compensated by spacing income. If you cannot forecast that range better than the market prices it, expected value after fees is negative.

Worked example with the tail attached

Range 60,000–64,000, 8 rungs, 500 spacing, 0.1 BTC per order, 0.1% per side.

def grid_round_trip_net(spacing_pct, fee_rate=0.001):
    """Net % per completed round trip; must clear 2x fees to be positive."""
    return spacing_pct - 2 * fee_rate

def grid_pnl(spacing, round_trips, qty, price, fee_rate=0.001):
    gross = round_trips * spacing * qty
    notional = qty * price
    fees = round_trips * 2 * notional * fee_rate
    return gross - fees

# 40 round trips/week, 0.1 BTC, ~$62k, $500 spacing
income = grid_pnl(500, 40, 0.1, 62_000)        # ~ $1,500 if it stays in the box

def inventory_loss(center, terminal, spacing, qty):
    """Mark-to-market on inventory if price trends straight through the grid."""
    rungs = int(abs(center - terminal) / spacing)
    held = rungs * qty
    avg_entry = (center + terminal) / 2 if terminal < center else center
    return held * (terminal - avg_entry)        # negative when terminal << center

# price breaks down to $45k
print(inventory_loss(62_000, 45_000, 500, 0.1)) # dwarfs a week of income

A breakdown to 45,000 leaves you holding a large long bought all the way down; the unrealized loss is many multiples of the cumulative spacing income. The week of "+$1,500" is a rounding error against the trapped inventory. That asymmetry is the strategy — flattering short-term Sharpe, hidden fat tail.

Spacing, fees, and the breakeven floor

Choice	Effect	Failure mode
Tight spacing	more fills, more income	fees swallow edge; `spacing% < 2·fee%` = bleed
Wide spacing	fewer fills, less drag	idle capital, fewer cycles
Arithmetic	fixed dollar rungs	% profit varies across range
Geometric	fixed % rungs	constant %; better for volatile crypto
Resting limits (maker)	rebate or low fee	none — prefer this
Market into grid (taker)	immediacy	fee drag destroys thin edge

Hard floor: minspacing% > 2 * takerfee%, and meaningfully above it to leave net edge. Grid orders are resting limits, so structure them as maker to earn the rebate; crossing the spread defeats the model. Account for all frictions per transaction costs and order types.

Sizing the range against volatility, not hope

The range and spacing are the whole game, and they should be derived from a volatility estimate, not from a chart that "looks rangy." Match spacing to a fraction of expected per-bar movement (see measuring volatility), and — critically — reserve capital below your lower bound sized for a breach, because the breach is the modal way grids end. Frame the worst case explicitly with maximum drawdown and CVaR on the trapped-inventory scenario, not on the in-the-box equity curve.

def expected_grid_ev(spacing_pct, round_trips, p_range, breakout_loss_pct, fee_rate=0.001):
    """Crude EV: range income weighted by P(stay) minus tail loss weighted by P(break)."""
    income = (spacing_pct - 2 * fee_rate) * round_trips * p_range
    tail = breakout_loss_pct * (1 - p_range)
    return income - tail        # negative whenever the tail isn't respected

The point of this sketch is that roundtrips and prange are guesses about future ranging, and the EV flips negative the moment you honestly price the breakout tail. Any backtest that omits the breakout scenario is overfit to a period that happened to chop.

Perp grids, leverage, and the inventory trap

Futures/perp grids can run short or levered, but adding leverage to a negative-gamma inventory problem is how grids blow up: a trend pushes inventory and unrealized loss while funding bleeds, and the liquidation price arrives precisely when the grid is most underwater. The inventory and the leverage compound the same directional risk — they do not diversify it.

Where it actually has edge (and where it doesn't)

Edge: genuinely range-bound, high-churn pairs where realized vol stays

below the move you are implicitly short, run maker-only, with reserved capital and a hard invalidation. This is a real but capacity- and regime-limited short-vol carry, not a durable alpha.

No edge: trending or breakout regimes (the opposite bet to

breakout trading); illiquid alts where thin books mean partial fills and the effective spread exceeds the spacing; tight grids where fees exceed spacing. Trading ETH/BTC instead of a USDT pair keeps you in crypto and the ratio often ranges even when both trend in USD — but in a broad sell-off the alt falls harder, so the grid accumulates the weaker asset exactly when it underperforms.

Conclusion

Grid trading is a discretized short-gamma, short-realized-volatility position: a steady income drip financed by accumulating inventory against the move, with a concave payoff and a fat left tail when price leaves the box. It has no alpha of its own — only a regime bet on range plus spread capture — so the skill is entirely in forecasting the range, deriving spacing from volatility, running maker-only above the fee floor, reserving capital for the inevitable breach, and pre-committing to an invalidation price. Treat the smooth equity curve as the warning sign it is, and never confuse a quiet backtest window with the future. For the directional and reversion counterparts, see breakout trading and mean reversion, and study market making to see what a grid is a crude, frozen imitation of.