Building a Profitable Arbitrage Bot Between Hyperliquid Spot and Perpetuals: Execution, Slippage, and Position Sizing

A trader observes that Bitcoin’s perpetual contract on Hyperliquid trades at $98,500 while the spot market sits at $98,200. The 300-dollar spread appears to present an immediate profit opportunity: buy spot, short perpetuals, pocket the difference. In reality, executing that trade profitably requires solving a cascade of technical and operational problems. Order latency, slippage on both legs, funding rate costs, liquidation risk, and capital efficiency will determine whether a spread that looks attractive on a price feed actually generates profit after costs.

Hyperliquid’s architecture—with its fully on-chain central limit order book, sub-second block times, and zero gas fees for trading—removes some traditional barriers to arbitrage automation. However, the same features that enable fast execution also attract sophisticated algorithmic traders and professional market makers. Building a bot that consistently captures spot-futures arbitrage requires precise order placement logic, realistic slippage models, strict position sizing discipline, and continuous monitoring of execution costs. This guide walks through the technical and financial framework needed to implement a viable arbitrage strategy on Hyperliquid.

Understanding the spot-perpetuals basis and funding mechanics

The fundamental opportunity in spot-futures arbitrage arises from the basis—the difference between a perpetual contract’s price and the underlying spot price. When perpetuals trade above spot, the basis is positive, and a trader can theoretically lock in a profit by buying spot and shorting perpetuals. When perpetuals trade below spot, the basis is negative, and the reverse trade is attractive. The basis itself is not profit; it is the maximum profit available before considering execution costs and time value.

Hyperliquid’s architecture removes several traditional friction points. On-chain settlement eliminates counterparty risk and the possibility that an exchange becomes insolvent between trade entry and position closure. Zero gas fees mean that closing the arbitrage position incurs no blockchain transaction cost. The maker fee of approximately 0.01% per side is considerably lower than traditional futures exchanges and reduces the total cost of the round-trip trade. For a 500-dollar basis on a $100,000 notional position, the entry and exit fees total roughly $2, leaving substantial room for profit at larger scales.

However, the basis narrows because of funding rates—periodic payments between long and short traders designed to pull the perpetual contract price toward spot. On Hyperliquid, funding occurs hourly. If perpetuals are trading above spot due to large long positioning, long traders pay short traders a positive funding rate. This cost gradually erodes the profit of a short perpetuals position. A bot must therefore account for the expected funding cost over the expected holding period and compare it to the initial basis. A 300-dollar spread that costs 400 dollars in funding over eight hours is not profitable, even if the math appears attractive at entry.

The relationship between basis, funding rate, and holding period defines the risk-reward structure. A profitable trade requires the initial basis to exceed the cumulative costs of execution, slippage, and funding. A bot should calculate the break-even funding rate as a function of time: if the current funding rate implies more than the break-even cost over a reasonable liquidation or take-profit timeframe, the trade is rejected. This discipline separates mechanically executing every observed spread from executing only those spreads that are likely to be profitable given the current market state.

Connecting to Hyperliquid’s API and order placement logic

Hyperliquid exposes its exchange data and trading functionality through a REST API and WebSocket connections. The REST API can retrieve historical data, account balances, and open positions; WebSocket connections allow subscription to real-time order book updates and order status changes. A bot typically maintains a local copy of the order book for each traded asset, updating it with WebSocket messages to compute the current best bid and ask prices.

Order placement on Hyperliquid’s CLOB requires constructing a signed transaction and submitting it to the chain. The Hyperliquid SDK simplifies this process, handling serialization and signature generation. A basic order-placement function accepts an asset, size, price, and order type (post-only, reduce-only, immediate-or-cancel, fill-or-kill) and returns an order confirmation or rejection. The critical insight for arbitrage is that orders do not fill instantaneously; they are queued in the order book and filled when the other side matches them. A market order on Hyperliquid consumes liquidity and incurs taker fees. A limit order that is placed above the current ask (for a buy) or below the current bid (for a sell) can fill passively and pay maker fees, but it may not fill immediately if the order book does not cross.

The arbitrage bot’s order logic must be atomic or sequenced carefully. If the goal is to lock in a basis spread, the bot should attempt to buy spot and short perpetuals as close in time as possible. If only one leg fills before the basis collapses, the bot is left with an unhedged position that may experience adverse price movement. One approach is to use immediate-or-cancel orders on both legs, accepting partial fills or rejections if the market moves too quickly. Another approach is to place limit orders on both sides and wait for both to fill before considering the arbitrage established. The choice depends on the bot’s tolerance for miss-rate and its required fill rate.

A production bot should also implement order rejection and retry logic. If a spot buy order is rejected due to insufficient balance, the bot should verify the balance, adjust the size, and resubmit rather than immediately abandoning the trade. Similarly, if a perpetuals short is rejected because it would exceed position limits or leverage constraints, the bot should check the reason and potentially adjust the position size or reduce open orders on other assets.

Modeling and measuring slippage in realistic conditions

Slippage is the difference between the expected fill price and the actual executed price. On Hyperliquid, it arises from two sources: order book depth and price movement during execution. If a bot places a market order to buy Bitcoin spot at the current ask price of $98,500, but the order consumes several orders on the book, it may fill at an average price of $98,520. The difference ($20) is depth slippage. Separately, if the market price moves from $98,500 to $98,550 between the time the order is placed and the time it is filled, that $50 is latency-driven slippage.

A bot should model slippage before deploying real capital. One method is to backtest historical order book snapshots and simulate market orders at various notional sizes, measuring the average fill price deviation. For a small arbitrage position (e.g., $10,000 notional), Hyperliquid’s deep order book may incur only 0.01% to 0.05% slippage on the spot leg and similar slippage on the perpetuals short. For a larger position ($100,000 notional), slippage can reach 0.1% to 0.3% or higher, depending on time-of-day liquidity and market volatility. A 300-dollar basis can evaporate quickly under realistic slippage assumptions.

In production, slippage should be tracked continuously. The bot can compare the expected fill price (based on the best bid-ask at order submission time) to the actual fill price and record the deviation. Over time, this empirical slippage model becomes more accurate than a static assumption. If observed slippage drifts upward—suggesting decreased liquidity or increased competition—the bot should reduce position size to maintain an acceptable profit margin.

A sophisticated approach is to implement latency arbitrage controls. If the bot’s orders are consistently filling at worse prices than the stated order book, it may be losing a latency race to faster participants. In that case, the bot could adjust its strategy: place smaller orders to reduce slippage, use limit orders to avoid market price risk, or focus on spreads wide enough to tolerate higher slippage. The alternative is to accept the latency disadvantage as a cost of operation and price it into the break-even basis threshold.

Position sizing, leverage, and liquidation risk management

Arbitrage is often described as «risk-free» because both sides of the trade are supposed to lock in a known profit. In practice, several forces can turn a locked-in trade into a loss. First, if the spot and perpetuals positions are held across different wallets or sub-accounts, they are not truly locked and can be liquidated independently. On Hyperliquid, perpetuals positions are subject to liquidation if the account falls below maintenance margin. Spot holdings in self-custody are not liquidated, but they can be stolen or lost. A bot should always maintain both legs of the trade in the same account or ensure that losses on one leg do not trigger cascading failures on the other.

Second, leverage magnifies losses. If a bot uses 10x leverage to amplify returns on a small basis spread, a 1% adverse move in the perpetuals price can wipe out the entire profit from the arbitrage and then some. The standard approach is to use minimal leverage or none at all on arbitrage positions. If the basis is 300 dollars on a 100-thousand-dollar position (0.3%), using even 2x leverage introduces a 0.6% liquidation risk if the position drifts against the arbitrageur. On Hyperliquid, perpetuals support up to 50x leverage, but arbitrage positions should use leverage conservatively or avoid it entirely.

Position sizing should be determined by available capital and acceptable loss magnitude. If the bot operates with $50,000 in account capital and the expected profit on a single arbitrage is $50, the trade should represent a tiny fraction of the account (e.g., $5,000 notional) so that a miss—where both orders execute but slippage or funding costs eliminate the spread—does not significantly impact the account. A rule of thumb is to limit a single arbitrage position to 1% to 5% of account capital; if market conditions allow, multiple smaller positions can be run in parallel to diversify timing and fill risk.

Liquidation risk should be continuously monitored. The bot should calculate the maintenance margin ratio (current margin / maintenance margin requirement) and pause new positions if it falls below a safety threshold, such as 2.0. For Bitcoin perpetuals at 20x leverage, a 5% move in price against the position will approach liquidation. An arbitrage position meant to hold for 30 minutes to 2 hours should never approach that risk level. The liquidation check should run after each fill and reject orders that would push the account toward danger.

Integrating data feeds and automating execution logic

A bot requires two information streams: real-time order book data and account state. The order book provides the current best bid-ask and depth, which the bot uses to identify spreads and calculate expected fill prices. The account state includes available balance, open positions, maintenance margin, and unrealized profit and loss. Both streams should be consumed via WebSocket to ensure low latency and responsiveness.

The execution loop typically runs every 100 to 500 milliseconds, though the specific interval depends on expected spread dynamics and system capacity. At each iteration, the bot: (1) reads the current order book for spot and perpetuals, (2) calculates the current basis and compares it to the minimum profitable spread (break-even basis plus a safety margin), (3) checks account balance and margin ratio, (4) if conditions are met, places buy-spot and short-perpetuals orders, and (5) once both are filled, opens a position monitor to track funding and slippage costs. This sequence should be as fast as possible, but not so fast that it overwhelms the API or places orders faster than the exchange can process them.

Edge cases require special handling. If one order fills but the other does not, the bot should implement a hedging routine: if the spot buy filled but the perpetuals short did not, the bot should immediately place a market short on the perpetuals (even at a worse price) to reduce directional risk. If the perpetuals short is filled first, a market buy on spot should follow. This residual-risk logic prevents the bot from being left with a naked long or short position that can suffer a large loss if the price moves sharply.

For detailed technical reference and API specifications, developers can review Hyperliquid’s official documentation and consider exploring additional resources at sites.google.com/cryptowalletextensionus.com/hyperliquid/ to supplement their understanding of the platform’s capabilities and integration patterns.

Backtesting and profitability validation before live trading

Before deploying capital, a bot should be backtested against historical data to validate the profit thesis. A backtest simulates the bot’s orders against historical order books and price data, calculating fills, slippage, fees, and funding costs. The output is a record of every trade, including entry price, exit price, profit, and loss. Over a large sample of trades (ideally thousands), patterns emerge: win rate (percentage of profitable trades), average win size, average loss size, profit factor (total wins / total losses), and maximum drawdown.

The backtest should use realistic assumptions. Slippage models should be based on observed market depth, not optimistic estimates. Funding rates should use historical averages or stress-test against worst-case rates. Order rejection rates should account for market moving against orders before they are filled. If a backtest shows 95% win rate with tiny losses, it is almost certainly too optimistic. A realistic arbitrage bot might achieve 60% to 85% win rate with an average win of $20 to $100 per trade and an average loss of $50 to $200 when slippage and latency eliminate the spread.

Once live trading begins, the bot should log every order placement, fill, and liquidation event. These logs are used to compare actual performance against backtest expectations. If live performance is significantly worse, the bot should be paused and debugged. Common reasons include: (1) live slippage is higher than the backtest model, (2) the bot is hitting order rate limits or experiencing API delays, (3) the basis spreads in the current market are narrower than the historical data suggested, (4) funding rates have increased, or (5) the bot’s order placement logic is being beaten by faster participants (latency arbitrage loss).

A rolling performance dashboard should track win rate, average trade profit, maximum loss, and Sharpe ratio (return per unit of risk) over the past week, month, and quarter. If the Sharpe ratio is below 1.0, the returns are not compensating sufficiently for the risk taken. If the maximum loss exceeds the acceptable risk per trade, position sizing should be reduced. Profitability in arbitrage depends on consistent execution and ruthless cost management. A bot that is profitable in backtests but unprofitable live is likely suffering from execution costs that were underestimated in simulation.

Scaling, competitive dynamics, and market sustainability

Hyperliquid’s position as a dominant on-chain perpetuals and spot exchange has attracted professional trading firms and algorithmic market makers. The effect is that spreads that were wide enough for retail arbitrage five years ago have narrowed significantly. Current spot-perpetuals spreads on liquid assets like Bitcoin often range from $50 to $300, compared to spreads of $500 to $2,000 in emerging markets or less liquid assets. Scaling an arbitrage bot to capture larger profits requires either (1) trading on larger sizes where fewer competitors operate, (2) focusing on less liquid assets with wider spreads, or (3) combining arbitrage with other strategies.

Less liquid assets introduce execution risk. A bot that can profitably arbitrage Bitcoin may struggle with Hyperliquid’s long-tail altcoins, where the order book is thin and slippage can consume the entire spread. Testing a bot on a new asset requires careful position sizing: start with small notional amounts, observe actual slippage, measure win rate, and only scale if performance meets expectations. Some assets will be perpetually arbitrage-free (spreads too narrow to overcome costs), and the bot should categorize them and skip them.

Market sustainability is a real concern. If too much capital chases arbitrage on Hyperliquid’s most liquid pairs, the spreads will narrow further, pushing down the profit per trade and potentially making the strategy unprofitable for smaller participants. Conversely, if market volatility increases (funding rates spike, slippage widens), arbitrage opportunities may widen again. A bot designed to scale with its profitable opportunities will periodically suspend or reduce activity when spreads are narrow and resume when volatility returns.

Operational monitoring and error recovery

A bot running continuously must be resilient to network outages, API errors, and unexpected market conditions. Production deployments should include health checks, error logging, and automatic restart logic. If the WebSocket connection to Hyperliquid drops, the bot should attempt to reconnect rather than crashing. If an order fails to place, the bot should log the error and retry with exponential backoff rather than hammering the API. If the account balance becomes negative (should not happen but can occur due to funding payments or liquidation), the bot should pause all new orders and alert the operator immediately.

A secondary concern is order book integrity. If the bot’s local copy of the order book becomes out of sync with the exchange’s actual book, subsequent trades will be based on stale information. Periodic full-book snapshots (e.g., every minute) can re-sync the local state. Similarly, the bot should fetch the current balance and position state at regular intervals and compare it to the bot’s internal accounting; discrepancies indicate a bug that should be investigated and fixed.

Downtime should be minimized but not at the cost of reliability. A bot that crashes every few days and loses a large trade due to a missing stop-loss is worse than a bot that is down 5% of the time but operates correctly when running. The standard approach is to run the bot in a containerized environment with automated restart, log errors to a persistent database, and have a human monitor alerts during trading hours. For a sophisticated setup, running multiple instances of the bot in a load-balanced configuration provides redundancy, though this introduces additional complexity in state synchronization.