Backtest your Hyperliquid strategy with real fees, funding, and slippage.
Keel backtests perp strategies across ~220 Hyperliquid markets on 15-minute bars and 1-hour funding rates. A production-grade portfolio simulator applies live fee schedules, per-asset slippage, and decomposed price-versus-funding P&L. The same pipeline of typed components that passes the backtest is the pipeline that trades live.
Three reasons most Hyperliquid backtests don’t survive contact with live.
Single-asset, no-funding, won’t-deploy. Each gap turns a backtest into a confidence trick — and Hyperliquid’s funding mechanics punish the second one in particular.
A signal that prints money on BTC alone often craters when you add ten more assets. Single-asset Jupyter backtests miss correlation, concentration, and rebalance friction — the things that actually drive portfolio P&L.
Run the strategy as a portfolio across the Hyperliquid universe. Volatility targeting, buffered rebalancing, and exposure caps are part of the simulation, not bolted on after.
Backtests that ignore funding payments and assume mid-price fills are fantasy. A carry strategy reads as alpha when funding is silent and as noise when it is modeled honestly.
Real Hyperliquid fees and per-asset slippage are applied per fill. Funding accrues hourly into the equity curve and is decomposed so you can see what is price and what is carry.
A backtest in a notebook is hard to translate to live trading. The translation layer between research code and production execution is where silent bugs hide for months.
The same structured pipeline that backtests is what runs live on your Hyperliquid account. No port from research to production — the buffered rebalancer in your test is the buffered rebalancer at the broker.
Under the hood
Structured strategy engine
Strategies are composable pipelines of typed components. The system validates every connection at edit time — errors caught before you backtest, not after you deploy.
AI built on the same system
AI doesn’t generate code — it composes from the same components you use. It understands valid connections, constraints, and trade-offs. Every strategy it builds is structurally valid.
Detailed backtest reports
Sharpe, Sortino, max drawdown, win rate, trade-by-trade logs. Compare runs side by side. Real fee and slippage modeling.
Version control for strategies
Every edit creates a new version. Compare any two versions side by side. Tag releases, restore previous versions, fork strategies. Your full history, always recoverable.
Auditable execution logs
Every live run is logged — what the strategy calculated, what orders executed, what filled. Full transparency.
Non-custodial by design
Your keys never touch our servers. Keel uses Hyperliquid’s native delegation. Sign once, revoke anytime.
A real run, shared from the app.
One Keel backtest, real numbers, viewable in the app via a shareable tearsheet URL. Run your own and share it the same way.
Funding-carry on Hyperliquid perps
Short the funding-payers, long the funding-receivers, scaled by realised volatility. Funding-decomposed P&L: most of the equity curve comes from the carry, not the price. Period: 2024-08-15 → 2026-04-30 (20 mo).
Verified Keel backtest. Past performance is not indicative of future returns.
Where each tool actually sits.
Honest comparison. The SDKs and the Rust crate are great primitives for DIY work; Coinrule is closer to a no-code bot builder. Keel is the full research-to-live loop on Hyperliquid.
| Feature | Keel | HL Python SDK | Coinrule | hyperliquid-backtest (Rust) |
|---|---|---|---|---|
| HL perp data coverage | ~220 perps · 15-min bars · 1h funding | WebSocket/REST · DIY caching | Spot-focused · limited perp window | Per-asset OHLC · DIY funding |
| Portfolio simulation (multi-asset) | Yes — vol-targeted, buffered rebalance | No — single-asset | No — per-rule, per-pair | No — single-asset |
| Funding modeled in P&L | Yes · decomposed price vs carry | DIY | No | Partial |
| Real fees + per-asset slippage | Yes — live fee schedule, bps slippage | DIY | Flat assumption | DIY |
| Backtest-to-live parity | Yes — same pipeline runs live | No — research only | Separate live engine | No — research only |
| Pricing | Free to start | Free (DIY) | $35/mo+ | Free (DIY) |
Competitor features summarized from public docs as of 2026-05-18. “DIY” means the primitive exists but the user wires it up.
Calculators that pair with a backtest.
Quick-hit tools for the questions that come up around a backtest — funding, liquidation, overfit risk. Free, no sign-up.
Funding APR calculator
Realized funding APR for any HL perp. Same 1h series the backtester reads.
Try the calculator →Overfit checker
Estimate the gap between in-sample Sharpe and what survives out-of-sample.
Try the calculator →Liquidation calculator
Find the liq price for any HL perp position. Pair with vol-targeting to set leverage that respects margin.
Try the calculator →Common questions
What data does the backtest run on?
Keel ingests ~220 Hyperliquid perpetual markets at 15-minute bars and 1-hour funding rates, with open interest where the venue publishes it. History depth varies per asset — newer listings simply have less. The cache is the same source the live execution path reads, so backtests and live trading work off identical price and funding series.
How is funding modeled?
Funding accrues into the equity curve on every 1-hour boundary using the actual Hyperliquid funding rate for each open position. P&L is decomposed so you can see price-only return, funding return, and combined return separately. This makes carry strategies and funding-aware sizing testable end-to-end rather than approximated.
What timeframes are supported?
The core timeframe is 15-minute bars (Hyperliquid's most reliable resolution for systematic perp work) with 1-hour funding. Pipelines can resample upward — hourly, 4h, daily — for slower signals. Sub-15-minute backtesting is not supported today; latency-sensitive strategies belong in a different tool.
How are fees and slippage handled?
Fees use the live Hyperliquid maker/taker schedule applied per fill. Slippage is modeled from a per-asset cost in basis points that you set explicitly — there's no hidden assumption. The default starting point is conservative; if your strategy has thin edge, raise the slippage knob and see whether it survives.
Does the backtest match live trading?
The same pipeline of typed components, the same buffered rebalancer, and the same volatility-targeting math run in both backtest and live. Live still diverges from backtest because of real-world slippage, market impact, and regime changes — execution logs let you compare expected vs actual fill by fill.
What about walk-forward optimization and Monte Carlo?
Today Keel ships single-window parameter optimization. Walk-forward optimization, Monte Carlo resampling of returns, and out-of-sample holdout at the strategy level are on the roadmap. If your decision depends on WFO or PBO numbers, use a dedicated tool now — try the calculators at /lab on momentumlab.com and watch the Keel changelog.
Do I have to use the web app, or is there a CLI?
Both. The Keel web app is the primary surface — sign up, compose a pipeline in the visual builder, run a backtest, view the results. If you would rather drive it from a terminal or an AI agent, pipx install keel-trade puts the keel CLI on your PATH: author strategies locally, run keel strategy create to upload, then keel backtest run against the same engine the web app uses. Both routes hit the same backtest engine and the same data.
Keep exploring
Methodology: how to backtest a Hyperliquid strategy
The full recipe — data, simulator, costs, validation. The canonical how-to for this pillar.
Backtest funding-rate strategies on Hyperliquid
Decomposed P&L for carry: price-only, funding, combined. Regime detectors on 1h funding.
Hyperliquid Strategy Builder
Compose the pipeline you want to backtest — typed components, validated connections.