Disclosure: CoinCodeCap may earn a commission if you sign up for Hyperliquid through links on this page. Open-source framework links may be tracked but the frameworks themselves are free. Risk warning: Algorithmic trading carries significant risk — always paper-trade on Hyperliquid testnet before deploying real capital.
How We Rank: CoinCodeCap evaluates Hyperliquid bot frameworks on six factors: HyperCore + HyperEVM coverage, language and SDK quality, authentication patterns, backtesting and historical data support, real-time WebSocket reliability, and ease of strategy development. We tested integrations end-to-end on testnet using public docs, GitHub repositories, and the Hyperliquid Builder Codes program.
Building a Hyperliquid trading bot in 2026 means picking from a small but very mature stack: official SDKs in Python and Rust, the multi-language CCXT library, Hummingbot’s connectors, and Freqtrade for retail-style strategy development. Every option handles ECDSA signing, agent wallet delegation, and Hyperliquid’s distinctive rate-limit model — the differences come down to which language you write in and how much strategy scaffolding you want out of the box.
Two facts every Hyperliquid bot framework has to navigate. First: rate limits are volume-based, not just request-based. You get 1 request per 1 USDC of cumulative trading volume, plus a 10,000-request buffer for new accounts. Batching helps — up to 39 orders in a single request count as weight 1. Second: order placement always routes through Hyperliquid’s public API at api.hyperliquid.xyz. Private RPC providers accelerate reads and streams; writes still go to the official endpoint. If you haven’t picked your RPC yet, our Hyperliquid RPC providers comparison covers the eight main options.
This guide compares seven Hyperliquid bot framework options across coverage, language support, authentication, and the strategy primitives each one ships with. If you want a no-code path instead, see our separate no-code Hyperliquid bot setup guide covering Coinrule, GoodCryptoX, and Hyperbot.
| Framework | Language | Auth Method | Strategy Scaffolding | Best For |
|---|---|---|---|---|
| Hyperliquid Python SDK | Python | API wallet (private key) | None — raw API | Custom bots, full API control |
| Hyperliquid Rust SDK | Rust | API wallet (private key) | None — raw API | HFT, latency-critical |
| CCXT | Python, TS, PHP, C#, Go | walletAddress + privateKey | None — unified API | Multi-exchange bots |
| Hummingbot | Python (configurable) | API key OR private key | Full — strategies + scripts | Market making, arbitrage |
| Freqtrade | Python (config + strategies) | walletAddress + privateKey | Full — backtest + dry-run | Retail strategy development |
| nktkas/hyperliquid | TypeScript | API wallet | None — raw API | Frontend-integrated bots |
| Hummingbot API | REST + Python client | API key | Full — cloud-deployable | Cloud/team deployments |
| 📌 Quick verdict — Custom strategy: Python SDK or CCXT. Strategy framework: Hummingbot or Freqtrade. Latency-critical: Rust SDK. | ||||
What to Look For in a Hyperliquid Bot Framework
Six criteria separate a Hyperliquid bot framework that ships fast from one that traps you in setup hell:
- Authentication model: Hyperliquid uses ECDSA signing with two patterns — API wallet (private key generated through
app.hyperliquid.xyz/API) or direct wallet private key. API wallets are safer because they cannot withdraw funds. Frameworks that default to API wallet (Hummingbot, Freqtrade, all official SDKs) are the right pick. - Spot vs perpetuals: Hyperliquid spot and perpetuals are separate connectors in most frameworks. Hummingbot exposes them as
hyperliquidandhyperliquid_perpetual. CCXT uses one class with method-level routing. Confirm both work for your strategy before committing. - HIP-3 market support: Permissionless perp markets need isolated-margin handling and full
issuer:asset-quotetrading-pair strings. Hummingbot and Freqtrade both support HIP-3 explicitly. The official SDKs require manual implementation. - Backtesting and historical data: Hyperliquid’s API only returns 5,000 historic candles per call, so backtesting needs incremental data collection. Freqtrade’s data download utility handles this automatically. Rolling your own with the SDK requires building the loop yourself.
- WebSocket reliability: Real-time order books, fills, and funding rates all stream over WebSocket. Frameworks with built-in retry logic, reconnection, and graceful REST fallback (CCXT, Hummingbot, Freqtrade) save days of debugging.
- Vault and sub-account support: Trading from a Hyperliquid vault or sub-account requires passing the vault address through to most API calls. CCXT 4.4.87+ supports this via
vaultAddressinccxt_config.options— older versions and rolled-your-own bots require manual handling.
How to Choose: A Decision Tree by Use Case
- Building a custom Python strategy from scratch? → Official Hyperliquid Python SDK. Direct API access, ECDSA handled automatically.
- Already running a multi-exchange bot stack? → CCXT. Same interface across Hyperliquid, Binance, Bybit, and 100+ other venues. Install Coincurve for the 900x ECDSA performance boost.
- Want a market-making or arbitrage strategy without writing the engine? → Hummingbot. Pre-built strategies, configurable spreads, backtesting, and Hyperliquid Foundation sponsorship.
- Doing retail strategy development with backtesting? → Freqtrade. Strong dry-run/backtest workflow, large strategy community, supports vaults and sub-accounts.
- Building latency-critical HFT or arbitrage? → Hyperliquid Rust SDK. Pair with co-located VPS from a provider that offers it.
- Frontend-integrated bot in a browser or Node.js app? → nktkas/hyperliquid TypeScript SDK.
- Deploying bots to a team or cloud? → Hummingbot API for centralized credentials, multi-bot orchestration, and a REST control plane.
Hyperliquid Python SDK (Official)
The official Python SDK at hyperliquid-dex/hyperliquid-python-sdk is maintained by the Hyperliquid core team and wraps the full REST + WebSocket API. It handles ECDSA signing automatically, exposes both spot and perpetual market endpoints, and is the closest you can get to raw API control without writing your own HTTP client. No strategy scaffolding ships with it — you implement signal generation, position sizing, and risk management yourself. If you’d rather not start from a blank file, check our guide to building a crypto trading bot for a step-by-step walkthrough.
- ✅ Official and current. Maintained by the Hyperliquid team — new endpoints land here first, including HIP-3 market support and Builder Codes integration.
- ✅ Full API surface area. All Info endpoints plus all Exchange endpoints (orders, cancels, transfers, vault deposits).
- ✅ Lightweight. No heavy dependencies, no strategy framework to learn — you wire it into your own bot architecture.
- ⚠️ No strategy scaffolding. You build position sizing, stop-loss logic, backtesting, and reconnection handling yourself.
- ⚠️ Single-language only. If you need TypeScript or Go for the same logic, switch to CCXT or use the community SDKs.
- 📌 Best for: Custom Python strategies, research scripts, and developers who want maximum control over execution flow.
| Detail | Value |
|---|---|
| Repo | github.com/hyperliquid-dex/hyperliquid-python-sdk |
| Auth | API wallet private key (recommended) or main wallet private key |
| WebSocket | Yes — Info subscriptions plus Exchange order events |
| HIP-3 markets | Supported via standard order endpoints |
| Strategy primitives | None — bring your own |
Hyperliquid Rust SDK (Official)
The official Rust SDK targets latency-critical workloads — HFT, market making, and execution venues where every microsecond from signal to order matters. Same API surface as the Python SDK, but with the performance characteristics Rust gives you: zero-cost abstractions, predictable garbage-collection behaviour (i.e. none), and tight memory control. If you’re running co-located near Hyperliquid validators in Tokyo and chasing tail-latency wins, this is the right choice.
- ✅ Production-grade performance. Rust’s lack of GC pauses gives predictable p99 latency — critical for HFT and arbitrage strategies.
- ✅ Official maintenance. Same team as the Python SDK, so feature parity arrives quickly.
- ✅ Memory safety. Borrow-checker eliminates whole categories of bugs that bite long-running trading processes.
- ⚠️ Higher learning curve. Rust is the right tool for the job, not the right tool for prototyping. Expect days of compile-time wrestling on day one.
- ⚠️ Smaller community. Fewer Stack Overflow answers, fewer reference implementations vs Python.
- 📌 Best for: HFT firms, market-making desks, and any strategy where you’ve already proven Python can’t hit your latency targets.
| Detail | Value |
|---|---|
| Repo | github.com/hyperliquid-dex/hyperliquid-rust-sdk |
| Performance | Sub-millisecond order construction; signing via secp256k1 native |
| Async runtime | tokio |
| WebSocket | Yes |
| Best paired with | Co-located VPS from Dwellir or HypeRPC’s JP region |
CCXT
CCXT is the multi-exchange Swiss Army knife — Python, TypeScript, PHP, C#, and Go all from a single unified API. Hyperliquid support is fully implemented and CCXT joined the Hyperliquid Builder Codes program, so trades routed through the library carry an attribution code. Trading pairs follow CCXT’s unified format (BTC/USDC:USDC for perpetuals); spot uses the same exchange class with method-level routing. The big performance tip: install Coincurve for ECDSA signing, which drops signing time from ~45ms to under 0.05ms.
- ✅ Five-language coverage. Same logic, same method names — write once, deploy on any stack.
- ✅ Joined Builder Codes program. Earn builder fees on each trade routed through the library, plus a 4% fee discount on the first $25M volume via the CCXT referral.
- ✅ Active maintenance. Hyperliquid endpoints update with every CCXT release — vault and sub-account support landed in 4.4.87.
- ⚠️ Coincurve install required for performance. Default Python ECDSA is 900x slower than Coincurve. Production bots must install it.
- ⚠️ Generic abstraction. Some Hyperliquid-specific features (HIP-3 market deployer config, builder code metadata) aren’t exposed natively.
- 📌 Best for: Multi-exchange arbitrage, copy-trading bots, and teams that need the same logic running across centralized and decentralized venues.
| Detail | Value |
|---|---|
| Languages | Python, TypeScript, PHP, C#, Go |
| Connectors | hyperliquid (spot) and hyperliquid_perpetual |
| Auth | walletAddress + privateKey (API wallet) |
| ECDSA performance | ~45ms default, ~0.05ms with Coincurve installed |
| Vault support | Yes — via vaultAddress in options (4.4.87+) |
Hummingbot
Hummingbot is the open-source algorithmic trading framework with built-in market-making, arbitrage, and liquidity-provision strategies. Hyperliquid is a sponsor of the Hummingbot Foundation, and the integration is one of the most polished — separate hyperliquid and hyperliquid_perpetual connectors, full HIP-3 market support, and both authentication modes (API key OR Arbitrum wallet + private key). If you want a market-making bot running by tomorrow without writing the matching logic yourself, this is the fastest path.
- ✅ Pre-built strategies. Pure market making, cross-exchange market making, AMM arbitrage, liquidity mining — configure parameters and deploy.
- ✅ Both auth methods supported. Use the API key generated in Hyperliquid’s web interface, or pass your Arbitrum wallet’s private key directly. API key is the safer default.
- ✅ HIP-3 markets work. Pass the full
issuer:asset-quotetrading-pair string and Hummingbot handles the isolated-margin requirements automatically. - ✅ Sponsored by Hyperliquid Foundation. Maintenance and integration depth are well-funded — bug reports get prioritized.
- ⚠️ Heavier setup. Hummingbot needs Docker, configuration files, and strategy scripts. Not the right pick for a 50-line script.
- 📌 Best for: Market makers, liquidity providers, arbitrage strategies, and anyone who’d rather configure a strategy than write one from scratch.
| Detail | Value |
|---|---|
| Connectors | hyperliquid (spot), hyperliquid_perpetual |
| Auth options | API key OR Arbitrum wallet + private key |
| HIP-3 support | Yes — isolated margin only |
| Strategy templates | Pure MM, Cross-exchange MM, AMM arb, Avellaneda MM, scripts |
| Deployment | Docker recommended; testnet variant available |
Freqtrade
Freqtrade is the most popular retail-focused crypto bot framework — Python, large strategy community, strong backtesting, and a clean dry-run mode for paper trading. Hyperliquid support arrived through CCXT, so configuration goes through the standard exchange section with a couple of Hyperliquid-specific gotchas. Use your API wallet’s private key (NOT your main wallet’s), pass your master wallet address as walletAddress, and optionally route through a vault or sub-account by setting vaultAddress or subAccountAddress in the CCXT options.
- ✅ Strong backtesting and dry-run. Test strategies against historical data with realistic slippage modelling before risking capital. Dry-run mode simulates trades without sending orders.
- ✅ Stop-loss on exchange. Hyperliquid supports stoploss-on-exchange via stop-loss-limit orders, and Freqtrade configures this automatically.
- ✅ Vault and sub-account routing. Run strategies from an isolated sub-account or a vault for risk separation.
- ✅ Active strategy community. Hundreds of community strategies on GitHub adaptable to Hyperliquid pairs.
- ⚠️ 5,000-candle limit. Hyperliquid’s API caps historical data at 5,000 candles per call. Backtesting against years of data requires incremental download over time.
- ⚠️ Market orders simulated as limits. Hyperliquid doesn’t support true market orders, so CCXT (and Freqtrade) place limit orders with 5% maximum slippage.
- 📌 Best for: Retail strategy developers, anyone who wants serious backtesting without writing the harness.
| Detail | Value |
|---|---|
| Backend | CCXT 4.4.87+ recommended |
| Auth pattern | walletAddress (master) + privateKey (API wallet) |
| Vault support | vaultAddress OR subAccountAddress in ccxt_config.options |
| Backtesting | Yes — with 5,000-candle per-call limit |
| Stop-loss on exchange | Yes — via stop-loss-limit orders |
Community TypeScript SDKs (nktkas/hyperliquid, nomeida/hyperliquid)
The official Hyperliquid docs link two community-maintained TypeScript SDKs: nktkas/hyperliquid and nomeida/hyperliquid. Both wrap the full Info + Exchange API and handle ECDSA signing. The choice between them comes down to TypeScript ergonomics and which one’s API surface fits your project — both are well-maintained and used in production. If you’re building a Next.js dashboard, an Electron desktop bot, or a Node.js trading service, these SDKs save you from writing the boilerplate.
- ✅ Officially recognized. Hyperliquid docs link both repos as the canonical TypeScript options.
- ✅ Frontend-friendly. Native TypeScript types make integration with React, Vue, and Next.js painless.
- ✅ Production-tested. Used by alternative Hyperliquid frontends and bots in active deployment.
- ⚠️ Community-maintained. Updates lag the official Python and Rust SDKs by a few days when major API changes ship.
- ⚠️ Two options to evaluate. Pick based on API ergonomics — there’s no clear “winner” between the two.
- 📌 Best for: TypeScript-native bots, Node.js services, and frontend-integrated trading interfaces.
| Detail | Value |
|---|---|
| Options | github.com/nktkas/hyperliquid and github.com/nomeida/hyperliquid |
| Language | TypeScript |
| API coverage | Full Info + Exchange surface area |
| WebSocket | Yes |
| Maintenance | Community — update lag of days, not weeks |
Hummingbot API
Hummingbot API is the newer cloud-deployable layer on top of the Hummingbot client — a REST API server that runs locally or remotely, manages exchange credentials, and orchestrates multiple bot instances. Hyperliquid is a first-class connector. The pattern: spin up the Hummingbot API server, register your Hyperliquid API key and master wallet address as a credential, then start strategies via REST or the Python client SDK. This is the right pick for teams with multiple bots, cloud deployments, or anyone managing strategies across multiple accounts.
- ✅ Centralized credential management. Register Hyperliquid (and other exchange) credentials once, reuse across multiple bot instances.
- ✅ REST + Python client. Drive strategies from external services, dashboards, or your own orchestration layer.
- ✅ Cloud-deployable. Run on a server in your preferred region — pair with co-located VPS for latency-sensitive workloads.
- ✅ Same connectors as Hummingbot client. All the strategy templates, HIP-3 support, and dual auth modes carry over.
- ⚠️ More moving parts. API server + database + bot processes. Overkill for a single solo strategy.
- 📌 Best for: Teams running multiple bots, cloud-native deployments, and traders who want to manage strategies through a dashboard or CI/CD pipeline.
| Detail | Value |
|---|---|
| Deployment | Local or cloud — Docker-compose recommended |
| API auth | HTTP Basic (admin/admin default — change for production) |
| Required Hyperliquid fields | hyperliquid_api_key (master address), hyperliquid_api_secret (private key), use_vault |
| Connectors | hyperliquid, hyperliquid_perpetual, plus all other Hummingbot connectors |
| Best paired with | Hummingbot Dashboard for visual orchestration |
Routing Verdict: Which Framework Wins by Use Case
- Custom Python strategy from scratch: Official Hyperliquid Python SDK. Maximum control, minimal dependencies.
- Multi-exchange arbitrage or copy-trading: CCXT with Coincurve installed. Single codebase, every exchange, builder code attribution included.
- Market making or pre-built strategy: Hummingbot. Configure spreads and let it run.
- Backtesting and retail strategy development: Freqtrade. Strongest dry-run + backtest workflow on this list.
- HFT or latency-critical: Hyperliquid Rust SDK + co-located VPS in Tokyo.
- TypeScript or Node.js bot: nktkas/hyperliquid or nomeida/hyperliquid.
- Multi-bot team or cloud deployment: Hummingbot API for centralized orchestration.
- No coding skills? See our separate no-code bot setup guide covering Coinrule, GoodCryptoX, and Hyperbot.
Three operational notes that apply across every framework. First: generate an API wallet via app.hyperliquid.xyz/API rather than using your main wallet’s private key — API wallets cannot withdraw, which limits damage if your bot server is compromised. Second: fund a separate sub-account or vault for bot trading so a runaway strategy can’t drain your full balance. Third: install Coincurve if you’re using CCXT — the default Python ECDSA implementation costs ~45ms per signature, while Coincurve drops it to ~0.05ms. For any bot placing more than a few orders per minute, this matters.
Builder codes are a real revenue line for serious bot operators. Hyperliquid pays up to 0.1% (10 bps) on perps and up to 1% (100 bps) on spot per fill, with a minimum of 100 USDC required to register a builder code. Over 176 builders are currently active, generating $40M+ in cumulative builder code revenue. CCXT and several other frameworks attach builder codes automatically when configured.
Frequently Asked Questions
What’s the best Hyperliquid trading bot framework for Python?
For pure Python development, the choice is between the official Hyperliquid Python SDK (raw API, no scaffolding), CCXT (multi-exchange unified API), and Freqtrade (full backtesting framework). Pick the official SDK if you want maximum control, CCXT if you trade across multiple venues, or Freqtrade if backtesting is central to your workflow. Hummingbot is also Python-based but ships with full strategy templates if you’d rather configure than code.
Does ccxt support Hyperliquid?
Yes. CCXT has full Hyperliquid support across Python, TypeScript, PHP, C#, and Go, exposing both spot and perpetuals connectors. Vault and sub-account routing landed in CCXT 4.4.87 via the vaultAddress option. Install Coincurve alongside CCXT for the 900x ECDSA signing performance improvement.
Can I run Hummingbot on Hyperliquid?
Yes. Hummingbot has dedicated hyperliquid (spot) and hyperliquid_perpetual connectors, and Hyperliquid is a sponsor of the Hummingbot Foundation. Both authentication modes work — API key generated through app.hyperliquid.xyz/API or your Arbitrum wallet’s private key — and HIP-3 permissionless markets are supported with isolated-margin handling. Use the testnet variant (hyperliquid_perpetual_testnet) to validate strategies before deploying real capital.
The right Hyperliquid bot framework depends on your language, your appetite for strategy scaffolding, and whether you’re chasing latency or breadth of exchange coverage. For most developers, the path is: prototype in the official Python SDK or CCXT, graduate to Hummingbot or Freqtrade once your strategy stabilizes, and only move to the Rust SDK if you’ve actually hit a Python latency wall. Pair whichever framework you pick with private RPC infrastructure — the public endpoint’s 100 req/min cap will throttle any production bot. If you want the strategy layer too, our Hyperliquid trading strategies guide covers leverage, copy trading, and bot setup patterns proven on the leaderboard.
Reviewed by Gaurav Agarwal, founder of CoinCodeCap. Gaurav has covered crypto exchanges, DeFi protocols, and trading platforms since 2018. Framework details verified against official documentation and GitHub repositories as of May 2026.
⚡ Bottom Line: Pick the official Hyperliquid Python SDK for custom strategies, CCXT (with Coincurve) for multi-exchange bots, Hummingbot for market-making out of the box, Freqtrade for backtesting-driven retail strategies, and the Rust SDK only if you’ve genuinely hit a Python latency wall. Always generate an API wallet through app.hyperliquid.xyz/API rather than using your main wallet’s private key. Pair any framework with private RPC infrastructure — the public endpoint’s 100 req/min cap will throttle any serious bot.
📋 Related Guides: Best Hyperliquid RPC Providers | No-Code Hyperliquid Bot Setup | Hyperliquid Fees Explained
📊 Comparisons: Hyperliquid vs dYdX, GMX & Competitors
⬆️ Full Review: Hyperliquid Review — Is It Safe, Legit & Worth Switching?
