Hyperliquid’s order book is fully transparent. Every order, every cancel, every fill — recorded against your wallet address, visible to anyone running L4 data. Viper is stealth execution infrastructure built for that constraint: six algorithms that break your size into passive, unpredictable pieces, running server-side for as long as the job takes.
L4 order feed
ETH-USDC · what observers see
| Wallet | Side | Size | Price |
|---|---|---|---|
| 0x7f2a41…9c03 | BUY | 12.4 | 1,909.3 |
| 0xb8e5d2…41af | SELL | 8.1 | 1,909.6 |
| 0x3c9017…6b7e | BUY | 4.7 | 1,909.2 |
| 0xa4d8f0…2e15you | BUY | 480.0 | 1,909.1 |
| 0x5e1b93…8d44 | SELL | 15.9 | 1,909.7 |
| 0xc07a26…f398 | BUY | 3.2 | 1,909.0 |
Hyperliquid’s public API exposes Level 2 depth — aggregated bids and asks. That alone tells observers a lot. Level 4 goes further: individual orders with wallet addresses, order IDs, timestamps and full parameters. Anyone running a node or subscribing to an L4 service can see exactly who placed what, when, and at what price.
For small orders this doesn’t matter. For anyone trading meaningful size — or anyone who would rather their strategy weren’t readable — it changes everything. Market makers, arbitrage desks and data-driven traders can watch you build a position in real time and trade against it.
On a CEX, only the exchange sees your orders. On Hyperliquid, the market sees them.
What that costs, and why it compounds
01
Markets are unpredictable. Entries get front-run, narratives shift overnight, and the best analysis still gets timing wrong. Execution quality is the part that stays within your control — every trade, every day. Over hundreds of fills, the trader with better execution outperforms the trader with better predictions, and the gap widens with time.
02
Fast execution is not good execution. Crossing the spread with full size is fast, visible, and expensive. Viper defaults to patience — maker-first where viable, time-distributed when impact matters, stealth when signalling is costly. Aggression is available, and applied when the cost of waiting exceeds the cost of crossing.
03
Most platforms serve dozens of venues and treat each one the same. Viper serves one. Every algorithm is tuned to Hyperliquid’s microstructure, matching behaviour and liquidity dynamics, and every order is validated against this specific book before it reaches the chain. The edge is in the specifics.
Viper was founded by an institutional trader — years across fixed income, derivatives and equities desks, spanning algorithmic execution and execution-performance measurement. The company was built on that world’s standards: every algorithm, recovery path and failure mode is tested to destruction against live markets before it ships, and the platform is traded hard by the people who build it.
Institutional-grade execution in crypto has traditionally sat behind sales processes, volume commitments and onboarding. Traders moving serious size on Hyperliquid mostly execute raw on the exchange instead — paying for it in slippage, leakage and fees. Viper closes that gap: the full execution suite — no minimums, no onboarding, no sales call.
The mission is larger than one venue’s order book. Execution science in equities and fixed income has decades of tooling behind it; crypto has never received the same attention or capital. Viper exists to close that distance — bringing the execution quality other asset classes take for granted to crypto traders, at pricing that reflects an efficient operation rather than an enterprise sales model.
All six are built on the same three principles, and all six ship with Passive, Neutral and Aggressive presets over full parameter control.
Orders should not reveal your total size, direction bias, or urgency. Large orders break into small, unpredictable pieces that read as ordinary flow.
Maker orders are cheaper, less visible, and cause less impact. Viper posts to earn the spread rather than pay it, and crosses only when it must.
The right order at the wrong moment still leaks information. Event-driven triggers act only when conditions provide cover.
GM
Liquidity-driven maker execution
Places and manages passive limit orders against live book state, repositioning as depth moves. Runs anywhere from patient accumulation to aggressive maker-only execution — earning the spread throughout, never crossing it.
GS
Stealth aggressive execution
Rests nothing on the book. Waits invisibly until your trigger price is hit, then sweeps in randomised clips with variable cooldowns. Zero presence before activation.
PM
Adaptive TWAP
Distributes an order across a time window with liquidity-responsive timing. Ahead of schedule it relaxes; behind schedule it tightens. Not a fixed-interval clock.
FS
Scaled order execution
Ladders limit orders across a defined price range with real-time fill monitoring. In Stealth mode only one level is visible at a time, so the market never sees the full ladder.
FB
Band-based execution
Executes within a defined price zone and pauses outside it, with levels that float against the market rather than staying fixed. Built for volatility where a static range would miss the move.
SE
An invisible stop that exits with an algo
Your stop is held server-side — nothing rests on the book to be hunted. When your level breaks, Smart Exit opens the gate and GlideMaker’s engine works the exit, maker-first; if the market recovers it pauses and re-arms. Exchange stops fire once, blind, and are done.
Trade Monitors observe live market activity — flow, volume, liquidity, price behaviour — and trigger execution when your conditions are met. Not a price alert that pings your phone: a full stealth execution that fires when the market gives you cover, and keeps doing it every time the conditions repeat.
Execution Baskets take it further, launching up to ten algorithms across a price range in a single action. Entries near market, take-profits above, stops below — each level running its own algorithm, tracked as one unit. Webhooks let a TradingView alert fire the same execution path.
These chains run server-side, around the clock, whether or not you’re watching.
Every execution plots your fills against market benchmarks in real time, and scores them in basis points once it closes.
vs Arrival
Did you beat the price at the moment you decided to trade?
vs TWAP
Did you beat the time-weighted market price across your window?
vs Sweep
Did you beat the cost of pushing the whole size through the book at once?
Maker fill rate
What share of your fills were passive — lower fees, less impact.
Participation
What share of market volume was you. Lower means less visible.
Browser-based tools stop when the tab closes. Viper runs server-side, and the difference isn’t only uptime — it’s what happens when something goes wrong at 3am while a GlideMaker is halfway through a working order.
Internal state is continuously reconciled against the exchange. Orphaned orders and missed fills are detected and corrected rather than hidden behind a stale local view.
The agent key is validated against the on-chain registry continuously. Revoke it from Hyperliquid and execution halts within seconds, with notification — no silent failure.
Weight consumption is tracked live, and data refresh is throttled before it can starve order placement of budget. Execution keeps priority under load.
Tick and lot compliance, safe rounding direction, notional and leverage bounds, and fat-finger thresholds — enforced before an order reaches the chain.
Maker-first with controlled fallback, aggression bounded by preset, runaway protection, stall detection, and a kill switch from the interface or Telegram.
Executions, fills, monitor configs and strategy watermarks survive restarts, rebuilds and deploys. State resumes from the exchange rather than from an assumption.
The practical test is a long one: launch an Execution Basket on Monday — entries, exits and stops across several algorithms — close the laptop, and find every leg still working on Friday: same process, same memory footprint, every fill accounted for. That is the bar the platform is built against — and it is reachable because Viper defends one venue, not twenty: every mechanism above is built against Hyperliquid’s specific failure modes, not generalised across exchanges.
The v1 API is not a reduced subset bolted on afterwards. It runs the same execution algorithms, against the same engine, with the same guarantees.
Account, connections, positions and leverage, orders and fills, execute and executions, monitors, webhooks, baskets, and market data — the same execution algorithms the interface uses, under a versioned /v1 path.
WebSocket is not read-only. Subscribe to account, execution and monitor channels, and issue commands over the same connection — not a polling loop wrapped in a socket.
Scope enforcement is active at the gateway. Provision each key with only the scopes your bot uses; a call outside its scope is refused with a structured error rather than silently allowed.
Everything lives under a versioned /v1 path with HMAC-signed requests. Errors return machine-readable codes in a structured envelope — never string-matching on messages — and the reference documents authoritative response shapes for every endpoint. Once published, the contract holds.
A typed Python client over the v1 surface — signing, retries and response models handled.
Full reference, authentication model and SDK documentation at docs.viperexecution.com.
Your funds stay on Hyperliquid under your own wallet. There is no deposit step, no locked capital, and no counterparty risk from the execution layer. This is enforced by Hyperliquid’s protocol, not by Viper’s policy.
| Action | Permitted |
|---|---|
| Place orders | YesWith your approval |
| Cancel orders | YesWith your approval |
| Read positions and balances | YesPublic chain data |
| Withdraw funds | NoNot possible |
| Transfer assets | NoNot possible |
| Change account settings | NoNot possible |
| Access funds if Viper is offline | YesFunds remain on the exchange |
Viper executes through Hyperliquid’s agent wallet architecture. The agent key can place and cancel orders only — withdrawal and transfer are not available to it at the protocol level. Trading authority is granted by an on-chain approval you sign once, visible on-chain, revocable at any time through the exchange.
The agent key is the only secret Viper stores. It never touches browser storage, is encrypted at rest under a key unique to your environment, and is decrypted in memory only for the duration of an execution.
If Viper goes offline, your funds remain accessible through Hyperliquid’s own interface. You are never dependent on Viper’s availability to reach your capital.
Three signatures at connection
A single builder fee collected through Hyperliquid’s native mechanism with every fill. No subscriptions, no platform fees, no feature gating, no deposits.
| Tier | 14-day volume | Builder fee |
|---|---|---|
| Standard | Up to $50m | 0.80 bps |
| Professional | $50m – $250m | 0.60 bps |
| Institutional | $250m – $1b | 0.40 bps |
| Elite | $1b+ | 0.25 bps |
Tiers are assessed daily against your rolling 14-day executed volume. When you cross a threshold the lower rate applies to all subsequent trades — no action required, no invoicing after the fact.
Every account gets the full platform
March 2026
Time-driven algorithms are blind between ticks. A TWAP firing every thirty seconds has no idea the book was swept at second fourteen. The case for scheduling execution against liquidity rather than against a clock.
Read the analysis →April 2026
Entry fill histories reconstructed wallet-by-wallet across $1.12bn of entry notional, measured against passive maker execution at each wallet’s own fee tier. Positions were included only where every entry fill back to position-open could be verified.
Read the analysis →Live in under a minute. No forms, no waiting lists — full access to every algorithm, monitor and analytic from the first fill. The platform ships continuously — the changelog is public, and feature requests reach the people who build it directly.
