Start here: building apps and front ends
Where an app or front end sits in the house, what it touches on HyperCore and the HyperEVM, which interfaces you use, and a reading order from a first request to contracts.
Where you are
Section titled “Where you are”You sit on the distribution floor: you bring users, and builder codes pay you on every order you route. You reach down to HyperCore through its API, and to the HyperEVM if you write contracts.
What that means for you
Section titled “What that means for you”- No listing, no partnership. Any app routes to the same books as the Hyperliquid app.
- Users keep custody. The user, or an API wallet they approved, signs. API wallets cannot withdraw.
- Your fee is capped twice. By the user’s approval, and by the protocol: 0.1% on perps, 1% on spot.
- Two toolchains. HyperCore has its own JSON API and signing; the HyperEVM is a standard EVM at chain id 999.
What you touch
Section titled “What you touch”An app or bot on HyperCore
Section titled “An app or bot on HyperCore”1Your usersThey connect a wallet and approve your builder fee once, up to a maximum they choose.2ReadThe info endpoint and the WebSocket serve books, positions and fills. No keys needed.3SignActions are EIP-712 typed data, signed by the user or by an API wallet.4SendThe exchange endpoint takes the signed action and HyperCore matches it in a block.5EarnEach order carries your builder address and fee. Fees accrue to you and are claimed like referral rewards.
A contract on the HyperEVM
Section titled “A contract on the HyperEVM”1DeployA standard EVM contract, chain id 999, gas paid in HYPE.2Read HyperCorePrecompiles from 0x800 return positions, balances and prices inside the same call.3Write to HyperCoreCoreWriter queues an order or transfer; HyperCore processes it after the HyperEVM block.4Move assetsTokens cross by transfer to a per-token system address, in either direction.
What you use
Section titled “What you use”| Interface | For | Start with |
|---|---|---|
Info endpoint, POST /info |
Every read: markets, books, balances, positions, fills | Your first request |
Exchange endpoint, POST /exchange |
Every signed action: orders, cancels, transfers, approvals | Orders |
| WebSocket | Streams, and signed actions over the same connection | WebSocket |
| HyperEVM JSON-RPC, chain id 999 | Contracts, with any Ethereum library | Blocks, gas and RPC |
Read precompiles, from 0x0000000000000000000000000000000000000800 |
HyperCore state from inside a contract | Precompiles |
CoreWriter, 0x3333333333333333333333333333333333333333 |
HyperCore actions from inside a contract | CoreWriter |
Any SDK wraps these. The pages below show the raw shapes, so you can check what it sends.
What to read, in order
Section titled “What to read, in order”Reading the exchange
Section titled “Reading the exchange”Architecture: info, exchange, WebSocketFoundationHyperliquid's API has three surfaces: an unsigned read endpoint, a signed write endpoint, and a WebSocket that streams data and can carry both.Your first requestFoundationReading Hyperliquid needs no key, no account and no risk: three unsigned POST requests return the list of markets, an order book and any address's positions.API servers and how state reaches youPractitionerAPI servers follow a node, keep a local copy of HyperCore state, answer reads from it, and reply to a transaction only once it executes in a committed block.Asset ids and namingPractitionerOrders name a market by an integer asset id and info requests by a coin string, and perps, spot, HIP-3 and outcomes each derive both by a different rule.Precision: tick size, lot size, significant figuresPractitionerA HyperCore price has at most 5 significant figures and a decimal cap set by szDecimals, a size at most szDecimals decimals, and outcomes use a 0.00001 grid.Data: historical, node and explorerPractitionerThe API keeps only recent history; a full record needs pagination, archived node data or your own node, and each trade counted once by its trade id.
Acting on it
Section titled “Acting on it”API wallets and agentsPractitionerAn API wallet is a key the master account approves to sign trades for it: it can place and cancel orders but cannot withdraw or send funds to another address.Nonces, expiry and API walletsPractitionerHyperCore keeps each signer's 100 highest nonces and accepts a new one only if unused, above the smallest, and within 2 days before and 1 day after block time.Signing from first principlesExpertL1 actions sign a keccak hash of their msgpack bytes, user-signed actions sign readable EIP-712 data, and one wrong byte in either recovers a stranger's address.Orders: place, modify, cancel, batch, dead man's switchPractitionerAn order is a signed action carrying a batch of compact orders; modify, cancel, TWAP and the dead man's switch are separate actions, each with its own response.WebSocket: subscriptions, post requests, heartbeatsPractitionerOne WebSocket streams book, trade and account updates as blocks execute and carries signed actions, but drops without warning and forgets every subscription.Builder codesPractitionerA builder code lets an app add its own fee to the orders it routes, up to a ceiling the user signed for, capped by the protocol at 0.1% on perps and 1% on spot.
Running it
Section titled “Running it”Rate limits and user limitsPractitionerHyperliquid meters each IP by request weight, 1200 per minute, and each address by actions: 10,000 plus one per USDC traded.Error responsesPractitionerHyperliquid reports errors at four layers, from HTTP status to a string inside a successful response, and several name a cause other than the real one.Debugging signatures and wire shapesExpertA signature over wrong bytes still verifies, so HyperCore recovers a stranger's address and says it does not exist; the fix is almost always the encoding.
Contracts on the HyperEVM
Section titled “Contracts on the HyperEVM”What the HyperEVM is, and is notFoundationThe HyperEVM is Hyperliquid's smart contract environment: it reads HyperCore state and queues HyperCore actions, but never executes them atomically.Moving assets between HyperCore and the HyperEVMPractitionerLinked tokens cross between HyperCore and the HyperEVM via per-token system addresses, with a decimal offset and a 200k-gas fee when leaving HyperCore.Reading HyperCore: precompilesExpertRead precompiles are 21 fixed addresses, 0x800 to 0x814, that return HyperCore state as of the EVM block's construction, and only at the latest block.Writing to HyperCore: CoreWriterExpertCoreWriter turns a contract call into a HyperCore action for the caller's own account, run after the EVM block, with no result returned and no revert on refusal.Execution order and timingExpertEach L1 block runs the EVM block, then EVM to HyperCore transfers, then CoreWriter actions; on mainnet most actions land within half a second, vault transfers in about 4 s.Footguns, measuredExpertTwelve ways a HyperEVM contract loses money or silently does nothing when it touches HyperCore, each with the on-chain evidence and the fix.
Want to run markets rather than an app? Start at deploying markets.