Hyperliquid Tick Size & Lot Size 2026: szDecimals Explained

The short version: a Hyperliquid price can have at most 5 significant figures and at most 6 − szDecimals decimal places on perps (8 − szDecimals on spot). Integer prices are always valid. A size must have no more than szDecimals decimal places. On top of that, an order must be worth at least $10. Get any of these wrong and the exchange answers "Price must be divisible by tick size" or "Order must have minimum value of $10".

Hyperliquid does not publish one fixed tick size per market like many centralized exchanges. The tick is derived from two rules and the current price, so it changes when a coin crosses a power of ten. That surprises bot builders and anyone placing orders through the API. This guide explains the rules from the official docs, shows the live values we pulled from the API on 22 October 2026 (around 07:05 UTC), lists the common mistakes, and gives you a short Python helper that rounds prices and sizes correctly. If you only want to watch a wallet's orders, positions and PnL, Hyperfolio shows them read-only, with no API keys.

Where szDecimals comes from

Every asset has a szDecimals value. For perps it is in the universe array of the meta (or metaAndAssetCtxs) info request. For spot it sits on each token in spotMeta, and the base token of the pair is the one that counts. szDecimals drives both rules: it is the lot size (the size step is 10^−szDecimals) and it limits how many decimals a price can have.

In our snapshot, the 178 active main-DEX perps split like this: 98 have szDecimals = 0 (whole units only), 51 have 1, 22 have 2, 5 have 3, ETH has 4 and BTC has 5. In other words, most perps trade in whole coins, while the expensive ones trade in tiny fractions.

Rule 1: the price (tick size)

From the Hyperliquid API docs, a price is valid when:

• it has at most 5 significant figures, and
• it has no more than MAX_DECIMALS − szDecimals decimal places, where MAX_DECIMALS is 6 for perps and 8 for spot, and
• as an exception, an integer price is always valid, whatever its number of significant figures. 123456 is fine even though 12345.6 is not.

So the effective tick is the larger of two steps: the step that 5 significant figures allows at the current price, and 10^−(MAX_DECIMALS − szDecimals). Above $100,000 the tick is simply $1, because only integers fit.

Docs examples (perps)

• 1234.5 is valid, 1234.56 is not (6 significant figures).
• 0.001234 is valid, 0.0012345 is not (more than 6 decimals).
• With szDecimals = 1, 0.01234 is valid but 0.012345 is not (more than 6 − 1 = 5 decimals).

Rule 2: the size (lot size)

Sizes are rounded to the asset's szDecimals. With szDecimals = 3, 1.001 is valid and 1.0001 is not. With szDecimals = 0, you can only trade whole units: 8 XRP, never 8.5.

Rule 3: the $10 minimum

The error list in the docs includes MinTradeNtl, "Order must have minimum value of $10", and for spot MinTradeSpotNtl, "Order must have minimum value of 10 {quote_token}". Because sizes are rounded to the lot step, the smallest valid order is usually a little above $10. Round up, not down, and leave a small buffer if the price is moving.

Live values: 22 October 2026 snapshot

Mark prices from metaAndAssetCtxs around 07:05 UTC. The tick column applies the rules above at that price, and the minimum size is the smallest lot-rounded size worth at least $10 at the mark. We checked the ticks against the live l2Book: BTC levels sat at 82,465, 82,462, 82,461; ETH at 2,430.9, 2,430.8; HYPE at 78.637, 78.636; kPEPE at 0.004487, 0.004486; XRP at 1.3399, 1.3398.

Perp	Mark price	szDecimals	Lot size	Tick size	Tick as % of price	Min size for $10
BTC	82,453.1	5	0.00001	1	0.0012%	0.00013
ETH	2,430.45	4	0.0001	0.1	0.0041%	0.0042
SOL	104.43	2	0.01	0.01	0.0096%	0.10
HYPE	78.619	2	0.01	0.001	0.0013%	0.13
XRP	1.3395	0	1	0.0001	0.0075%	8
DOGE	0.079639	0	1	0.000001	0.0013%	126
kPEPE	0.004486	0	1	0.000001	0.022%	2,230

Two things stand out. First, kPEPE's tick is capped by the 6-decimal limit, not by significant figures, so it is relatively coarse (about 2.2 basis points). Second, the tick moves with price: if XRP fell below $1, 5 significant figures would allow 0.99999, so the tick would shrink from 0.0001 to 0.00001. If ETH rose above $10,000, its tick would grow from 0.1 to 1. Do not hard-code ticks; compute them from the price.

Worked examples

• BTC at 82,453.5: 6 significant figures and not an integer, so it is rejected. Send 82453 or 82454.
• ETH at 2,430.45: 6 significant figures, rejected. Send 2430.4 or 2430.5.
• HYPE at 78.6197: rejected. 5 significant figures gives 78.620, sent as 78.62.
• kPEPE at 0.0044865: 7 decimals, rejected. Send 0.004486 or 0.004487.
• SOL size 1.234: szDecimals = 2, rejected. Send 1.23.
• XRP size 7: valid lot, but 7 × 1.3395 = $9.38, below the $10 minimum. Send 8.
• Spot token with szDecimals = 2: prices can have up to 8 − 2 = 6 decimals, still capped at 5 significant figures.

Market orders, TP/SL and slippage prices need rounding too

A market order on Hyperliquid is an aggressive limit order with a price limit (see our order types guide). That limit price must respect the same rules. The official Python SDK does this in its market helper: it moves the mid by the slippage, then rounds to 5 significant figures and to 6 − szDecimals decimals for perps (8 for spot). If you compute a slippage or trigger price yourself, for example mid × 1.03, round it the same way before sending. The same applies to TP/SL trigger prices (TP/SL guide).

Trailing zeros and float pitfalls

The signing docs list trailing zeros as a common source of signature errors, and the tick size page says they should be removed. Send "78.62", not "78.620". The SDK's float_to_wire formats numbers with 8 decimals, raises an error if that changes the value, and strips trailing zeros. Two more habits help:

• Round with the rules, then format. Binary floats such as 0.1 + 0.2 are not exact, so convert through a string or Decimal when building the wire value.
• Cache szDecimals from meta at startup and refresh it occasionally, because new listings arrive and values can change. Each meta call costs request weight (see rate limits).

Python helper

This script reads metaAndAssetCtxs, computes the tick, lot and $10 minimum for a few coins, and includes round_px and round_sz functions you can reuse. It only reads public data. To place real orders, start on the testnet and follow our Hyperliquid API Python guide.

import math
import requests

INFO = "https://api.hyperliquid.xyz/info"

def post(body):
    return requests.post(INFO, json=body, timeout=10).json()

def tick_size(px, sz_decimals, is_spot=False):
    """Smallest valid price step at this price level."""
    max_dec = (8 if is_spot else 6) - sz_decimals
    if px >= 1e5:                       # integer prices are always allowed
        return 1.0
    sig_step = 10 ** (math.floor(math.log10(px)) - 4)   # 5 significant figures
    return max(sig_step, 10 ** -max_dec)

def round_px(px, sz_decimals, is_spot=False):
    if px >= 1e5:
        return float(round(px))
    max_dec = (8 if is_spot else 6) - sz_decimals
    return round(float(f"{px:.5g}"), max_dec)

def round_sz(sz, sz_decimals):
    return round(sz, sz_decimals)

def min_size(px, sz_decimals, min_notional=10.0):
    step = 10 ** -sz_decimals
    return math.ceil(min_notional / px / step) * step

if __name__ == "__main__":
    meta, ctxs = post({"type": "metaAndAssetCtxs"})
    for a, c in zip(meta["universe"], ctxs):
        if a["name"] in ("BTC", "ETH", "SOL", "HYPE", "XRP", "DOGE", "kPEPE"):
            px, d = float(c["markPx"]), a["szDecimals"]
            print(f'{a["name"]:6} px={px:<12} szDecimals={d} lot={10**-d:g} '
                  f'tick={tick_size(px, d):g} min_size_$10={min_size(px, d):.{d}f}')

Output on 22 October 2026, 07:04 UTC:

BTC    px=82453.1      szDecimals=5 lot=1e-05 tick=1 min_size_$10=0.00013
ETH    px=2430.45      szDecimals=4 lot=0.0001 tick=0.1 min_size_$10=0.0042
SOL    px=104.43       szDecimals=2 lot=0.01 tick=0.01 min_size_$10=0.10
DOGE   px=0.079639     szDecimals=0 lot=1 tick=1e-06 min_size_$10=126
kPEPE  px=0.004486     szDecimals=0 lot=1 tick=1e-06 min_size_$10=2230
XRP    px=1.3395       szDecimals=0 lot=1 tick=0.0001 min_size_$10=8
HYPE   px=78.619       szDecimals=2 lot=0.01 tick=0.001 min_size_$10=0.13

One detail: when you round a price to the nearest tick, decide the direction on purpose. For a passive buy, round down so you do not cross the spread by accident (a post-only order that would cross is rejected as BadAloPx). For an aggressive buy limit, round up so the limit stays at least as generous as you intended.

Order book aggregation is not the tick size

The l2Book request and the WebSocket book feed take an optional nSigFigs parameter (2 to 5) that groups levels. With nSigFigs = 3, BTC levels showed at 82,400, 82,300, 82,200 in our check. That is only a display grouping. The tradable tick is still $1. See the WebSocket API guide for the book feeds.

Why it matters for traders, not just bots

• Cost of crossing: on a coarse tick like kPEPE's, the minimum spread is about 2.2 basis points, which adds to fees and slippage.
• Small accounts: the $10 minimum and whole-unit lots decide the smallest position you can open, which matters when you size with a position size calculator.
• Grid and market-making bots: grid steps that are not multiples of the tick get rejected or silently rounded by your code. See the market making guide.

Frequently asked questions

What is the tick size on Hyperliquid?

There is no fixed table. A price can have up to 5 significant figures and up to 6 − szDecimals decimals on perps (8 − szDecimals on spot), and integers are always allowed. On 22 October 2026 that meant $1 for BTC, $0.1 for ETH and $0.001 for HYPE.

What does "Price must be divisible by tick size" mean?

Your price has too many significant figures or too many decimals for that asset. Round to 5 significant figures, then to 6 − szDecimals decimals (8 − szDecimals for spot), and remove trailing zeros.

What is the minimum order size on Hyperliquid?

The order must be worth at least $10 (10 units of the quote token on spot), and the size must be a multiple of the lot step 10^−szDecimals. For BTC at about $82,450 that was 0.00013 BTC.

Where do I find szDecimals?

In the universe array of the meta info response for perps, and on each token in spotMeta for spot.

Does the tick size change?

Yes, with price. When a coin crosses a power of ten, the 5-significant-figure rule gives a different step. ETH above $10,000 would move to a $1 tick, for example.

Do I need to care if I trade in the Hyperliquid app?

The app rounds for you. These rules matter when you use the API, a bot, or a third-party front end, or when you wonder why a limit price was adjusted.

See what your orders actually did. Paste any wallet into Hyperfolio to track positions, fills and PnL in one read-only view, free. Trading on Hyperliquid? Use code HYPERFOLIO for 4% off fees (how the referral works).