Hyperliquid Trading Bot (2026): Python Quickstart, GitHub Bots, Grid and Telegram Bots

Three ways to run a Hyperliquid trading bot

Hyperliquid itself listed 179 perp markets at the last site build and traded $6.15B of perps in 24 hours (as of November 3, 2026), on a fully on-chain order book where orders and cancels cost no gas. That makes it the busiest venue for bots among the perp DEXs, and the reason the cheap route (your own code) is also the most common one. For the API itself (endpoints, signing, first order) read our Hyperliquid API guide; this page is about running a bot on top of it. Comparing venues first? Perp DEX APIs for trading bots compared.

Hyperliquid trading bot in Python: setup and code

1. Open and fund the main account. Join Hyperliquid with HOLYGRAIL, deposit at least 5 USDC of USDC (smaller deposits can be lost), and trade once from the app. The minimum order is $10 of notional on perps. Testnet first? The testnet faucet needs a mainnet deposit from the same address, so the mainnet account comes first either way (Hyperliquid testnet guide).
2. Optional: a sub-account for the bot (More → Sub-Accounts). Sub-accounts unlock after $100,000 of volume (10 at first). They share your fee tier and count as separate users for rate limits, but referral discounts do not apply to them. See sub-accounts explained.
3. Create an API wallet (More → API). "API wallets (also known as agent wallets) can perform actions on behalf of an account without having withdrawal permissions." You get 1 unnamed and 3 named API wallets per account plus 2 named per sub-account, each valid for up to 180 days. How to store and rotate the key: API wallet security.
4. Install the SDK: pip install hyperliquid-python-sdk (version 0.24.0, MIT licence, Python 3.9+). Its examples/ folder has a script for each building block: basic_order.py, basic_agent.py, basic_schedule_cancel.py, basic_ws.py.

One detail trips up most first bots: the API wallet only signs. To read balances and orders you query the real account address; querying the API wallet's address returns an empty account.

A post-only grid with a dead man's switch (Python)

This places five buy and five sell ALO (add-liquidity-only, i.e. post-only) orders on ETH, 0.5% apart, in one batched action, then arms a cancel-all 60 seconds ahead. ETH sizes have 4 decimals and prices at most 5 significant figures, so near ETH's $2,442 mark on October 22, 2026, prices move in $0.1 steps and 0.01 ETH (about $24) clears the minimum.

import os, time
import eth_account
from hyperliquid.exchange import Exchange
from hyperliquid.info import Info
from hyperliquid.utils import constants

ACCOUNT = os.environ["HL_ACCOUNT_ADDRESS"]   # main account address
SUB = os.environ.get("HL_SUB_ACCOUNT")        # optional: the bot's sub-account
TRADER = SUB or ACCOUNT                       # the account the orders land in (for reads)
agent = eth_account.Account.from_key(os.environ["HL_API_WALLET_KEY"])  # cannot withdraw

info = Info(constants.MAINNET_API_URL, skip_ws=True)
ex = Exchange(agent, constants.MAINNET_API_URL, account_address=ACCOUNT, vault_address=SUB)

COIN, LEVELS, STEP, SIZE = "ETH", 5, 0.005, 0.01
mid = float(info.all_mids()[COIN])

orders = []
for i in range(1, LEVELS + 1):
    for is_buy, sign in ((True, -1), (False, 1)):
        px = round(mid * (1 + sign * STEP * i), 1)
        orders.append(dict(coin=COIN, is_buy=is_buy, sz=SIZE, limit_px=px,
                           order_type=dict(limit=dict(tif="Alo")), reduce_only=False))

print(ex.bulk_orders(orders))                            # one action, 10 orders
ex.schedule_cancel(int(time.time() * 1000) + 60_000)  # cancel all in 60 s unless re-armed

The part that makes it a bot is the loop that reacts to fills. This one listens to your fills over the SDK's WebSocket and puts the opposite order one step away, so each filled buy becomes a sell above it and the reverse:

STATE = dict(seen=set())

def on_fills(msg):
    data = msg["data"]
    if data.get("isSnapshot"):          # first message replays recent fills
        return
    for fill in data["fills"]:
        if fill["coin"] != COIN or fill["tid"] in STATE["seen"]:
            continue
        STATE["seen"].add(fill["tid"])
        px, sz = float(fill["px"]), float(fill["sz"])
        bought = fill["side"] == "B"
        new_px = round(px * (1 + STEP) if bought else px * (1 - STEP), 1)
        ex.order(COIN, not bought, sz, new_px, dict(limit=dict(tif="Alo")))

ws_info = Info(constants.MAINNET_API_URL)            # opens the WebSocket
ws_info.subscribe(dict(type="userFills", user=TRADER), on_fills)

while True:                    # keep the dead man's switch armed; each re-arm is one action
    ex.schedule_cancel(int(time.time() * 1000) + 300_000)   # cancel all in 5 min unless re-armed
    time.sleep(240)

What it still lacks before real money: a maximum position, a stop bound outside the range that flattens with a reduce-only order, reconnect logic, and handling for "Post only order would have immediately matched" (re-quote one tick away). schedule_cancel must be at least 5 seconds ahead and can fire at most 10 times a day (reset at 00:00 UTC); every re-arm is an action against your address budget, which is why the loop re-arms every 4 minutes rather than every few seconds. The SDK has no TWAP or trailing-stop helper (0.24.0, checked October 22, 2026); those actions are built by hand, as in our TWAP API example. Code is an illustration, not production software.

Hyperliquid trading bots on GitHub

If you would rather run proven code than write your own, these are the open-source projects people searching "hyperliquid trading bot github" usually end up with. We read each repository and its docs on October 22, 2026; none is an endorsement, and we have run none of them with money.

Builder fees and referral codes in bot code. Open-source bots are free, but some earn from your volume the same way apps do. CCXT, the library under Freqtrade and many custom bots, acts as soon as it has your credentials (when it loads markets or sends its first order): it sends a setReferrer with the code CCXT1 (errors are ignored, so an account that already has a code keeps it) and approves a 0.01% builder fee for its own builder address, which it then adds to every order. Builder approvals must be signed by the main wallet, so with an API-wallet key the approval fails and CCXT sends orders without a builder. refSet: true skips the referral call; builderFee: false removes the fee, although CCXT still approves its builder at 0% and tags orders with it. Hummingbot's docs say its client tags orders for attribution only. A referral code is set once per account, so add HOLYGRAIL (how the referral code works) before you connect any bot.

Hyperliquid grid bot: fee math and failure modes

A grid rests buy limits below the price and sell limits above it, one per level. When a buy fills it re-quotes a sell one level higher, and the reverse; each buy-then-sell is a cycle that earns the spacing times the level's notional. It is a bet that price oscillates inside the range. Hyperliquid has no native grid UI: you run it through the API (the code above), an open-source bot or a hosted grid bot. Orders and cancels cost no gas; the costs are fees, funding on held inventory and the address rate limit.

Tier-0 fees from Hyperliquid's schedule; a referral code and HYPE staking lower them, volume tiers lower them further. Every grid order should be Alo: if it would cross, it is rejected instead of paying the taker fee.

Worked example. $10,000 in a neutral ETH grid, range ±5%, 20 levels, so spacing ≈ 0.5% and $500 per level. One cycle earns $2.50 gross, pays $0.15 in maker fees and nets $2.35. Ten cycles in a day net $23.50, about 0.24% of capital before funding; zero cycles because price walked out of the range earn nothing and leave you holding inventory. Each order needs at least $10, so a small account cannot be split into a hundred levels.

• Breakout and inventory. If price falls through the bottom of a neutral grid, every buy has filled and no sell will: in the example, $5,000 of ETH bought on the way down, now underwater. Set a stop bound just outside the range that cancels the ladder and flattens the position.
• Leverage. Size on the fully filled side, not on the per-level margin. With 5x per level a full buy side is $25,000 of ETH against $10,000 of equity: by Hyperliquid's liquidation formula (ETH maintenance margin 2%) liquidation sits about 39% below the average entry. At 10x it is $50,000 and about 18%, a move ETH has made within a week many times.
• Funding bleed. $5,000 of long inventory pays $1.50 a day at the baseline rate, comparable to a day of cycle fees, and several times that when longs are crowded.
• Dead bot, live orders. Re-arm schedule_cancel on every loop so a crash cancels the ladder.
• Range set by hope. Derive the range from recent realised volatility plus a buffer, not round numbers.

No code? Hosted grid bots connect through an API wallet you approve and charge a builder fee on top of Hyperliquid's: Dextrabot lists 0.01% per trade for its Hyperliquid grid bot, 2 to 36 grids (even numbers) in cross margin only. Aster's order-book perps have a native futures grid with 0% maker fees, and Lighter Standard charges 0% maker and 0% taker but has no grid, so you still need a bot (Lighter grid bot).

Hyperliquid Telegram bots and hosted bots: who holds the key

Telegram bots trade Hyperliquid from a chat. What separates them is where the trading key lives. From their own documentation, read October 22, 2026:

• PvP (pvp.trade). Creates a wallet per user whose private key "is stored and encrypted by Turnkey" and can be exported; an existing Hyperliquid account can be linked with an API key instead. Its fee table starts at 0.025%–0.04% on perps at level 1, and the first deposit must be at least 10 USDC. PvP also owns the Hyperdash terminal (Hyperdash review).
• Hypurr Fun. The bot creates a personal wallet with an exportable private key, or you import a key or link an API wallet. Its docs list a 1% fee on trades in its Hpump launchpad market and no fee for ordinary HyperCore trades.
• Copy and grid platforms (Dextrabot, copy apps): API wallet you approve plus a builder fee; Dextrabot's copy trading is 0.055% per trade. More in Hyperliquid copy trading.

Two things to know before you use one. A wallet the bot creates is a new Hyperliquid account: it starts without your referral code and with whatever code the bot sets, and its key sits with the provider's key vault, however well protected. Linking an API wallet to an account you already hold keeps withdrawals with your own wallet. Neither bot documents which builder or referral code its orders carry; check the fee line on your fills.

Built-in automation: TWAP, Scale, Chase, trailing stop

The order form on Hyperliquid has three tabs, Market, Limit and Pro. The Pro menu holds TWAP, Chase, Scale, Stop Limit, Stop Market, Take Limit, Take Market and Trailing Stop. For many people who search for a "bot", these are enough:

Docs (order types, exchange endpoint) and the app's order form, checked October 22, 2026. TP/SL triggers on the mark price. There is no native iceberg order and no native grid or DCA bot. A TWAP runs on the exchange, so it keeps working if you close the browser; Chase does not. Details: Hyperliquid TWAP orders, trailing stop tutorial, all order types.

Hyperliquid API rate limits a bot must respect

Orders cost no gas, so the ceiling on how much a bot can do is the rate limit, not the fee. There are two kinds: per IP (how fast you can talk to the API servers) and per address (how many actions your account has earned by trading).

Source: Hyperliquid docs "Rate limits and user limits" and "Nonces and API wallets", re-read October 22, 2026. Sub-accounts count as separate users for address-based limits. A batch of n orders is one request for the IP limit but n requests for the address limit.

The address budget. Every address starts with 10,000 actions and earns one more for each 1 USDC of volume. Check where you stand with the userRateLimit info request (info.user_rate_limit(address)): it returns cumVlm, nRequestsUsed, nRequestsCap and nRequestsSurplus. A grid bot that cancels and re-places 20 orders every minute uses 28,800 actions a day, so a new address runs dry in about 8 hours unless the bot trades enough notional to earn the difference; after that it is throttled to one action every 10 seconds. The fix is a quieter bot: modify only when price has moved a full step, widen the grid and let fills, not a timer, drive changes. An account can also buy headroom with reserveRequestWeight at 0.0005 USDC per request (10,000 actions for 5 USDC).

The IP budget. Polling clearinghouseState (weight 2) every 100 ms is 600 requests and 1,200 weight a minute: the whole budget. The same account data arrives by WebSocket at no REST cost. Batching orders in groups of up to 79 keeps each batch at weight 2 or less.

• WebSocket for data, REST for actions. Subscribe to l2Book, userFills and orderUpdates; keep local order and position state.
• Batch every 100 ms, with ALO (post-only) orders in separate batches from IOC and GTC, because ALO-only batches are prioritised by validators. Send cancels with the fast flag.
• Modify instead of cancel-and-replace, back off with jitter after a rejection, and never drop reduce-only or flatten commands when your local token bucket is empty.
• One process, one API wallet, one sub-account. Nonces are tracked per signer, so separation avoids collisions (API wallets and sub-accounts step by step).

DCA, funding carry and market making bots

DCA (dollar-cost averaging)

Buy a fixed amount on a schedule, for example $50 of spot HYPE or BTC every day. Spot orders must be at least 10 units of the quote token, and a $50 market buy costs $0.035 at the 0.070% spot taker fee. A limit order slightly below the price (0.040% maker) is cheaper if some days may not fill. A native TWAP is not a DCA tool: it slices one order over at most 7 days and does not repeat.

Funding carry (delta neutral)

Hyperliquid funding is paid every hour and capped at 4% an hour. Its interest component is 0.01% per 8 hours, about 11.6% a year paid by longs to shorts when the premium is zero. A carry bot holds spot and shorts the perp to collect it: BTC funding added up to 0.7305% over the 30 days to October 15, 2026. Entry and exit cost roughly $23 on $10,000 at base taker fees, so the trade needs weeks to pay, and funding can turn negative. Full method and a calculator: funding rate arbitrage guide.

Market making: maker fees, rebates and the real risks

Market making on Hyperliquid is permissionless: fund an account, create an API wallet and quote both sides with post-only orders. The docs say there is no designated market maker program, no special rebates or fees and no latency advantages; everyone gets the same schedule.

Why retail quoting on majors loses money. On September 25, 2026 the public book showed spreads of BTC 0.12 bp ($1), ETH 0.37 bp ($0.10), HYPE 0.11 bp, NEAR 2.43 bp, against a base maker fee of 1.5 bp per side. A quote that captures the whole BTC spread still pays more in fees than it earns. Retail makers who last quote wider on less crowded markets, keep inventory small and remember that held inventory pays hourly funding; scheduleCancel and a separate monitor are not optional. Without running a bot: HLP, the protocol vault, market-makes across Hyperliquid (APR at the last build -0.09%, 4 days lock-up after each deposit; it can lose money; see the vaults guide).

What a Hyperliquid bot pays in fees

Hyperliquid fee schedule via our facts registry; spot volume counts double toward tiers. Spot base fees are 0.070% / 0.040%. HYPE staking takes 5–40% off, and the referral discount (4% on your first $25M) applies on top. No gas on orders or cancels; a USDC withdrawal costs 0.2 USDC plus a tiny HyperEVM gas fee in HYPE.

On $1M of monthly taker volume, a bot pays $450 at the base rate and $432 with the 4% referral discount; a maker-only bot on the same volume pays $150. A third-party bot adds its builder fee on top (Hyperliquid caps builder fees at 0.1% on perps and 1% on spot; revoke approvals in More → Builder Codes). Details: Hyperliquid fees.

Security and risk controls

• API wallets cannot withdraw, but they can trade your balance into the ground. Use one per bot and per sub-account, and never reuse an API wallet address: once deregistered, its nonce history may be pruned and old signed actions could be replayed.
• Expiry: API wallets last at most 180 days. Put the expiry date in your calendar so a bot does not silently stop.
• Dead man's switch: schedule_cancel cancels all open orders at a time you set unless you push it forward. Combine it with reduce-only exits.
• Hard limits in code: maximum position, maximum orders per minute, daily loss limit and a manual kill switch.
• Read the code you run: fake bot repos (above) and poisoned packages exist; pin dependency versions and run bots on a machine that holds no main wallet key.
• Liquidation distance: keep leverage low on bots; see how to avoid liquidation cascades.
• Where you live: Hyperliquid's Terms exclude the US, Ontario and sanctioned regions; a bot does not change that (restricted countries).

FAQ

Want a free-to-trade venue for a slow bot? Lighter charges 0% on Standard accounts (code 718610TD); see the Lighter API guide.

Disclosure: HOLYGRAIL and 718610TD are our referral codes; we earn a share of fees paid by referred accounts. Code is an illustration, not production software or financial advice. Limits, fees, SDK details, GitHub repositories and bot documentation were checked on October 22, 2026.