Hyperliquid Trading Strategies — Automated Market-Making, Funding Arb & Risk Controls (2026)

Hyperliquid

Building a bot is the easy part. Deciding what it should trade, and keeping it alive when a machine is executing at 3am and the funding rate flips, is where most automated traders lose money. This guide is the strategy-and-operations companion to our trading bot setup guide: that one covers wiring up API wallets and the Python SDK, this one covers the strategies worth running, the risk controls that keep them from blowing up, and what actually breaks when a bot runs 24/7.

I have been writing trading bots since 2016, across centralized order books, DeFi AMMs, and now on-chain perpetuals. The strategies below are not textbook definitions. They are the handful that hold up on Hyperliquid's on-chain CLOB, with the caveats I wish someone had told me before I lost money learning them.

Can you run automated trading strategies on Hyperliquid?

Yes, and the exchange is built for it. Hyperliquid exposes a full REST and WebSocket API, dedicated API wallets that can trade but never withdraw, and roughly 1,200 requests per minute of headroom, all with zero gas per order. That means you can place, cancel, and requote thousands of times a day without execution costs eating the edge, which is exactly what automated market-making and arbitrage strategies need to work. The mechanics of connecting are covered in the setup guide; this article assumes you can already place an order and focuses on which strategy to run.

The four strategy families that fit Hyperliquid's CLOB

Every automated strategy is a bet on one of two things: that price will stay in a range, or that it will move. Hyperliquid's on-chain central limit order book, hourly funding, and maker rebates tilt the economics toward liquidity-providing, range-based strategies, but momentum plays have a place when volatility expands. Here are the four families that earn their keep, and where each one fits.

Market-making

Market-making means continuously quoting a bid below and an ask above the mid price, earning the spread plus the maker rebate every time both sides fill. On Hyperliquid the maker rebate (0.015% on perps at base tier, better with HYPE staking tiers) means you are literally paid to provide liquidity, and zero gas lets you maintain dense, frequently-refreshed quote ladders. The catch is inventory: when the market trends, one side fills repeatedly and you accumulate a position moving against you.

When it works: calm, range-bound, liquid markets. What kills it: trending markets and toxic flow. The fix is inventory skewing: widen and pull back the quote on the side you are already long or short, so the book naturally pushes you back to flat. A market maker without inventory management is a machine for buying high and selling low.

Funding-rate arbitrage

Funding-rate arbitrage captures the funding rate as yield by holding a delta-neutral position: short the perp on Hyperliquid while holding the equivalent spot (or an offsetting long elsewhere) so price movement nets out and you keep the funding. Because Hyperliquid settles funding hourly rather than every eight hours like most centralized venues, you collect more frequently and can exit faster when a rate normalizes. During momentum periods, altcoin perp funding can run above 0.1% per settlement.

When it works: when funding is persistently elevated and you have inventory on both legs. What kills it: basis drift (the spot and perp legs diverge), fees on both legs, and rates mean-reverting before you have earned enough to cover the round trip. It is a real edge but a low-return, capacity-heavy one, so treat it as a yield strategy, not a get-rich trade.

Trend and breakout

Trend strategies enter in the direction of a confirmed move (a break above resistance, a moving-average crossover, a volatility expansion) and ride it with a trailing or fixed stop. Unlike the two strategies above, this is directional: you are betting price moves and accepting that most signals fail while a few large winners pay for the losers. Hyperliquid's sub-10ms WebSocket price feed gives a bot the reaction time to enter on the break rather than three candles late.

When it works: when volatility expands and markets trend cleanly. What kills it: chop. In range-bound conditions a breakout bot gets whipsawed on every false break. Pair it with a regime filter (only trade breakouts when realized volatility is rising) and it stops bleeding in sideways markets.

Mean-reversion

Mean-reversion is the mirror image: fade extreme moves on the assumption price snaps back to a short-term average. A bot buys sharp dips and sells sharp rips within a defined band, often sized so it scales in as the move extends. On a liquid perp with tight spreads this can be a steady earner in ranging conditions.

When it works: range-bound markets with mean-reverting microstructure. What kills it: a genuine trend or a liquidation cascade. The very moment "it always bounces" stops being true is the moment mean-reversion hands back weeks of profit. A hard stop and a maximum scale-in count are non-negotiable, because the strategy's instinct is to add to a losing position.

Risk controls for unattended execution

A bot loses money faster than a human because it never hesitates. The single most important thing I have learned in a decade of automation is that risk controls are not a feature you add later. They are the first thing you build, before a single line of strategy logic. Here are the controls that every unattended strategy on Hyperliquid needs, in priority order.

1. Maximum position size. A hard cap on exposure per asset, checked every loop. This is the backstop against a runaway strategy, whether a market maker that keeps getting filled on one side or a mean-reversion bot scaling into a trend. If the cap is hit, the bot stops adding and, ideally, starts reducing.
2. Daily loss limit. If cumulative loss for the day exceeds a set threshold, the bot cancels everything and halts until you manually restart it. No exceptions, no "it'll come back." Most catastrophic bot losses are a bad day that the operator let run because they were not watching.
3. Kill switch. A single command that cancels all open orders and flattens every position immediately. Build it early, and test it regularly, because the one time you need it is during an outage or a fat-finger config change, and a kill switch you have never tested is a kill switch that does not work.
4. Stale-order detection. Orders sitting at a price the market has moved away from are free money for someone else. If a quote is more than N seconds old and price has moved beyond a threshold, cancel it. This is the fastest way to stop bleeding on a laggy loop.
5. Connection monitoring. If the WebSocket drops or REST calls fail several times in a row, cancel all open orders before attempting to reconnect. The worst state a bot can be in is disconnected with live orders it can no longer manage.

The reason to write these first is that funding and liquidation mechanics behave differently when a machine is trading. A human notices funding turning against a position and closes it; a bot holds it through settlement after settlement unless you coded the check. A human sees a liquidation cascade forming and steps aside; a mean-reversion bot buys straight into it. Every one of these controls exists because I have watched a bot do the dumb thing while I was asleep.

Running a strategy 24/7: infrastructure and monitoring

Running a strategy around the clock is an operations problem as much as a trading one. The bot needs to run somewhere reliable, reconnect cleanly when the network hiccups, and, most importantly, tell you the moment something is wrong. The strategy can be perfect and you will still lose money if the process dies silently at 4am and you find out at noon.

Where to run it. A small cloud VPS geographically close to the exchange (Tokyo or Singapore for Hyperliquid) minimizes round-trip latency; the difference between 50ms and 200ms matters for competitive market-making and breakout entries. Run the bot under a process supervisor (systemd, pm2, or a container with a restart policy) so a crash restarts automatically, but pair auto-restart with a startup check that cancels any orphaned orders from the previous run before quoting again.

What to monitor and alert on. Push alerts to Telegram or similar for: every fill, position changes beyond a threshold, any risk-control trigger, and, critically, a heartbeat. If the bot has not checked in for N minutes, that silence should page you. The failures that hurt are not the loud errors that print a stack trace; they are the silent ones where the process is alive but the strategy loop has stalled. Log obsessively for the first month of any new strategy, and watch it like a hawk, because the conditions that expose a bug are always the ones you did not simulate.

Backtest, then paper-trade, then risk real money

Never take a strategy from idea straight to live capital. There are two validation steps, and they prove different things. Backtesting against historical data proves the strategy has an edge; paper-trading on testnet proves your execution (order handling, rate-limit behavior, reconnection) actually works. Skip either one and you are debugging with real money, which is the most expensive classroom in the world.

Backtesting. Pull historical candles and funding from the Hyperliquid API and replay your strategy logic against them. The goal is not a beautiful equity curve. What matters is understanding how the strategy behaves in the regimes it will hate: a strong trend for a mean-reversion bot, a chop for a breakout bot. Be ruthless about costs; include realistic fees and slippage, because a strategy that only works at zero cost does not work.

Paper-trading on testnet. Hyperliquid's testnet mirrors the live API surface with free faucet USDC. Run the bot there for at least a week before mainnet. This is where you catch the bugs backtesting cannot: how your order sizing rounds against real tick sizes, whether your rate-limit handling holds up, what happens when a fill arrives while you are mid-requote. Switch to mainnet only after the bot has behaved on testnet through at least one volatile session.

How automation changes the fee math

Fees look trivial on a single trade and dominate the outcome across thousands. Any automated strategy lives or dies on its all-in cost per round trip, and Hyperliquid gives you several levers to lower it: the maker rebate, the HYPE-staking fee tiers, and the referral discount all stack. For a market maker or arbitrage bot placing thousands of maker orders a day, moving from taker to maker fills and climbing one staking tier can be the entire difference between a profitable strategy and a losing one.

The practical implications for strategy design:

• Prefer maker fills. A strategy that pays the taker fee on every entry has a much higher hurdle than one that provides liquidity and collects the rebate. Where the strategy allows, quote passively and let the market come to you.
• Spot volume counts double toward fee-tier progression, so a bot that touches spot markets climbs tiers faster.
• The referral discount (4% on the first $25M of volume) applies to API orders too, so for a high-frequency bot it compounds across every fill.
• Model fees into the backtest, not as an afterthought. The strategies that survive contact with real costs are the ones you costed honestly before deploying.

A decade of bot development, distilled

After ten years of building trading bots across every kind of exchange, the lessons that matter most are not about clever strategies. They are about discipline and operations. If you take nothing else from this guide, take these:

1. Start with the simplest strategy that has an edge. A single-pair market maker or a basic funding-arb bot. Get deployment, monitoring, and risk controls rock-solid before adding strategy complexity. Complexity you cannot monitor is risk you cannot see.
2. Risk management is the strategy. Two traders can run the identical signal and one compounds while the other blows up. The difference is position sizing, loss limits, and a kill switch that actually works.
3. Every edge decays. Markets change, competition arrives, and the strategy that printed last quarter goes flat. The skill is not writing one perfect bot; it is continuously adapting and retiring strategies that have stopped working.
4. Automation removes hesitation, which cuts both ways. A bot executes your discipline flawlessly and your bugs flawlessly. Respect that symmetry.

If you have not built the bot yet, start with the trading bot setup guide for API wallets and the Python SDK, then reach for the API trading guide and the Hyperliquid API reference for endpoint-level mechanics and order types. Prefer to follow a proven trader instead of writing your own logic? Copy trading mirrors another account's strategies automatically. And if you still need to fund your account, the deposit guide covers every route onto Hyperliquid.