How Many Grids Should a Grid Bot Use?

Grid count sets the step size of every trade a grid bot makes, using one formula: step = range ÷ grids. The same $10,000 price range split into 10 grids trades in roughly $1,000 jumps; split into 50, it trades in roughly $200 jumps. More grids mean more frequent, smaller fills. Fewer grids mean larger, less frequent ones. Neither is universally correct — the right count depends on how the asset really moves inside that range.

The Formula: Step = Range ÷ Grids

A grid bot divides a price range into evenly spaced levels, then places buy and sell orders at each one. The distance between two adjacent levels — the step — is just the range divided by the grid count. A $70,000–$80,000 range ($10,000 wide) split into 10 grids produces a step of $1,000; the same range split into 50 grids produces a step of $200.

That step size is the single number that determines everything else about how the bot behaves: how often it fills an order, how much profit each fill captures, and how sensitive the whole setup is to trading fees.

Three Patterns, Compared

None of the three is the default correct choice. The right one depends on how the specific asset moves inside the specific range chosen, not on a round number that feels reasonable.

A Worked Example

Take a $70,000–$80,000 range on an asset trading at $75,000, with $5,000 allocated to the grid. At 10 grids, the step is $1,000 and each of the 10 levels gets roughly $500 of capital; a single fill captures a full $1,000 move's worth of profit before fees. At 50 grids, the step shrinks to $200 and each level gets roughly $100 of capital; a fill captures a $200 move's worth of profit before fees, but the bot fills five times more often for the same total price distance covered.

Total profit potential over a full round trip through the range is similar in theory between the two — more fills at a smaller size versus fewer fills at a larger one — but the practical outcomes diverge once fees and actual price behavior enter the picture. If the asset chops narrowly, the 50-grid setup captures that chop the 10-grid setup would sit through untouched. If the asset makes one sharp $4,000 move through the range, the 10-grid setup captures large chunks of that move in a handful of fills, while the 50-grid setup fills rapidly through many small levels — still profitable, but paying the combined trading fee on each of those extra fills along the way.

What Actually Changes When You Add More Grids

Adding grids doesn't just add more lines to a chart — it changes the bot's entire trading rhythm. More grids means smaller steps, which means the bot needs smaller price moves to trigger a fill, which means more total fills over the same period of time. Each individual fill captures less profit, since the profit per cycle scales roughly with the step size.

The trade-off shows up clearest at the extremes. A 10-grid setup on a wide range waits for bigger moves and captures more per trade when they happen, but sits idle through smaller chop. A 50-grid setup on the same range fills constantly through that same chop, capturing many small profits — but each one is smaller, and fees eat a larger share of it.

Why It's Not That Simple

The biggest mistake isn't picking too few or too many grids in the abstract — it's picking a count that doesn't match the asset's actual volatility inside the chosen range. An asset that moves in sharp, wide swings wastes a 50-grid setup's fine resolution; most fills would skip past several levels at once during a fast move, and the bot spends most of its configured levels waiting for price to come back and fill them individually. An asset that chops narrowly and frequently underuses a 10-grid setup, sitting mostly idle while it waits for moves the range rarely produces.

Fees compound the problem in the wrong direction. A step of $200 on a $70,000 asset is roughly 0.29% — on some exchanges, close enough to combined round-trip trading costs that a fill can land near break-even before slippage is even considered. Aster's own taker fee, for comparison, runs 0.04% per side — a real, published rate, not an illustrative one — which shows how thin the margin between step size and fees can get on a fine grid even before funding costs are added on futures. The finer the grid, the more fees matter to the math, which is the practical ceiling on how many grids make sense before adding more starts subtracting from returns rather than adding to them.

How to Actually Choose

Start from how the asset has really moved inside the range being considered, not from a preferred round number. Pull a recent price history for the exact range and look at the size of typical moves within it — an asset repeatedly making $150–$300 swings inside the range suggests a step in that neighborhood makes sense, which points toward the grid count that produces it for the chosen range width. An asset making $1,000+ swings within the same range suggests a coarser grid captures those moves better than a fine one that gets skipped over.

Capital available matters too, independent of volatility: the same investment split across 50 grids puts less capital behind each individual order than splitting it across 10, which affects both position sizing per fill and how much of the allocation sits unused waiting for price to reach levels never triggered in a fast, directional move.

Turning the Pattern Into a Setup

None of this needs to be guessed. Backtesting a specific range and grid count against how the asset moved through that same range historically shows the fill frequency and per-cycle profit a given configuration would have produced — before committing real capital to find out the hard way. Demo trading extends the same test to live, current conditions with nothing at risk.

The range-bound grid playbook covers the range-selection side of this same decision — grid count and range width aren't independent choices, and testing them together in backtesting catches mismatches that testing either one alone would miss.

Test a specific grid count against how the asset moved historically — before funding it. Bitsgap's Grid bot lets you set range, grid count, and order size, then backtest or demo it against real market data with no capital at risk.

FAQ

How many grids should I use in a grid bot? There's no universal number — it depends on how the asset moves within the chosen price range. An asset that swings in large, infrequent moves fits a lower grid count (larger steps); an asset that oscillates frequently in smaller moves fits a higher grid count (smaller steps). Backtesting a specific configuration against the asset's own recent price history is the practical way to check, rather than defaulting to a round number.

What's the formula for grid bot step size? Step size equals the price range divided by the number of grids: step = range ÷ grids. A $10,000 range split into 10 grids produces roughly $1,000 steps; the same range split into 50 grids produces roughly $200 steps. Step size is what determines fill frequency and profit per cycle, not the grid count number by itself.

Can too many grids hurt a grid bot's performance? Yes. A very fine grid produces a small step size, and if that step gets close to the combined round-trip trading fees, each fill can close near break-even or at a loss once fees and slippage are counted. There's a practical ceiling on grid count for a given range and fee structure, past which adding more grids subtracts from returns rather than adding to them.

Does grid count matter more than range width? Neither matters more in isolation — they work together. The same grid count produces a different step size on a wide range versus a narrow one, and the same range produces a different step size depending on grid count. Testing range and grid count together, rather than choosing one and treating the other as fixed, catches mismatches that testing either alone would miss.

Should I change my grid count if an asset's volatility changes? It's worth reconsidering, yes. A grid count chosen for a calmer period can end up too fine once volatility rises — fills happen fast, fees eat more of each one, and the bot spends its configured levels catching up to moves that skip past several steps at once. Backtesting the existing configuration against the asset's more recent, more volatile price action shows whether the original count still fits, rather than assuming a setup that worked before still matches current conditions.