HYPERLIQUIDGRPC STREAMING NODE
Hyperliquid gRPC Streaming: Real-Time HyperCore Data Feeds
Real-time HyperCore data streaming via gRPC. Trades, orders, book updates, TWAP, events, and L2/L4 order book depth pushed instantly. Protobuf serialization, zstd compression.
Hyperliquid gRPC streaming provides real-time HyperCore data directly from the margin and matching engine via bidirectional gRPC streams. 9 stream types available: Trades, Orders (18+ lifecycle statuses), Book Updates, TWAP execution, Events (funding, liquidations), Blocks, Writer Actions, and gRPC-exclusive L2/L4 order book streams with aggregated price levels and individual order-level depth.
USE CASES
- + Real-time L2/L4 order book streaming (gRPC-exclusive)
- + Trade fill and order lifecycle monitoring
- + Funding rate and liquidation events
- + HFT & algorithmic trading data feeds
- + TWAP execution tracking
- + Block-level data analysis
KEY FEATURES
- + 9 bidirectional gRPC streams
- + L2/L4 order book depth (gRPC-exclusive)
- + Protobuf serialization (3-10x smaller than JSON)
- + Native zstd compression (~70% bandwidth reduction)
- + Configurable filters by coin, side, user, event
- + Sub-millisecond latency
Hyperliquid is built on HyperBFT, a custom consensus mechanism derived from Hotstuff that delivers sub-second block finality. The architecture is split into two layers: HyperCore — the on-chain margin and matching engine handling positions, funding, and market data — and HyperEVM, an EVM-compatible environment for Solidity smart contracts. gRPC streaming connects directly to HyperCore, giving you the fastest possible access to order book state, execution events, and market data before it propagates through REST or WebSocket layers.
Protobuf serialization delivers 3-10x smaller messages than JSON equivalents. Subscribe once, receive continuous updates with sub-millisecond overhead. Configurable filters by coin, side, user, and event type to receive only the data you need. Port 10000 dedicated for gRPC traffic. Bidirectional streaming means you can adjust your subscriptions on the fly without reconnecting — add or remove markets, change filters, all within the same persistent connection.
Trading systems and HFT: use Trades and Orders streams for real-time fill tracking with 18+ order lifecycle statuses. Market makers subscribe to StreamL2Book for aggregated depth or StreamL4Book for individual order-level granularity — both gRPC-exclusive and unavailable via WebSocket or REST. Risk and analytics platforms: Events stream delivers funding rate changes, liquidation notifications, and system events the moment they occur. TWAP stream tracks execution progress for large orders. Blocks stream provides raw blockchain data for on-chain analysis and compliance monitoring.
gRPC vs WebSocket vs REST — Hyperliquid Protocol Comparison
| Stream | gRPC | WebSocket | REST |
|---|---|---|---|
| Trades | ✓ | ✓ | ✓ |
| Orders | ✓ | ✓ | ✓ |
| Book Updates | ✓ | ✓ | ✓ |
| TWAP | ✓ | ✓ | ✓ |
| Events | ✓ | ✓ | ✓ |
| Writer Actions | ✓ | ✓ | ✓ |
| Blocks | ✓ | — | — |
| StreamL2Book | ✓ | — | — |
| StreamL4Book | ✓ | — | — |
| Format | Protobuf | JSON | JSON |
| Connection | Bidirectional stream | Persistent | Request/Response |
| Best for | HFT, market making | Real-time apps | On-demand queries |
gRPC provides 9 streams vs 6 for WebSocket. Three streams — Blocks, StreamL2Book, and StreamL4Book — are gRPC-exclusive and not available through any other protocol. For trading systems where latency and bandwidth matter, gRPC with protobuf serialization is the optimal choice.
Shared gRPC for development and testing, dedicated nodes for production with guaranteed resources and zero rate limits. Full HyperEVM compatibility included. 24/7 monitoring, automatic failover, direct support via Slack and Telegram.
AVAILABLE
LOCATIONS
Select the location closest to your infrastructure for optimal latency, or choose multiple regions for enhanced redundancy and global coverage.
Frankfurt
Frankfurt is a major hub for blockchains infrastructure in Europe, with a high concentration of validators. Its top-tier data centers and strong network backbone provide ultra-low latency and reliable performance.
Amsterdam
Amsterdam is a key location for many blockchains infrastructure with a strong presence of validators. Hosting infrastructure here provides low latency, stable connectivity, and reliable performance for any workload.
Tokyo
Tokyo hosts numerous major data center operators providing core infrastructure. Strategic location for Asia-Pacific with low latency to major exchanges and validators.
New York
New York is a major hub for blockchains infrastructure in the United States, with a high concentration of validators. Its top-tier data centers and strong network backbone provide ultra-low latency and reliable performance.
MORE COMING SOON
MORE COMING SOON
PRICING
We encourage you to review our selection of services and our price list for Hyperliquid gRPC Streaming Node. Our pricing is both market-aligned and transparent. Please take your time to compare options and make the perfect choice for your needs. Expect quality and clear value.
POPULAR
Hyperliquid RPC + gRPC
$200 /month
- + gRPC streaming endpoints
- + Real-time order book & fills
- + WebSocket included
- + Community support
Dedicated gRPC Node
$1800+ /month
- + Dedicated gRPC infrastructure
- + Zero rate limits
- + Priority support
- + Custom filters
Hyperliquid gRPC Streaming Node FAQ
[NEED HELP?]
gRPC streaming delivers real-time HyperCore data via 9 bidirectional streams. Data types include Trades, Orders (18+ lifecycle statuses), Book Updates, TWAP execution, Events (funding, liquidations), Blocks, Writer Actions, and gRPC-exclusive L2/L4 order book depth. Uses protobuf serialization for 3-10x smaller messages than JSON.
9 stream types: Trades, Orders, Book Updates, TWAP, Events, Writer Actions, Blocks, StreamL2Book (aggregated price levels), and StreamL4Book (individual order-level depth). L2/L4 order book streams are gRPC-exclusive and not available via WebSocket or REST.
Sign up, get your gRPC endpoint and API token. gRPC runs on port 10000. Authenticate via x-token metadata header. Connect using any gRPC-compatible client (Python, Go, Node.js, Rust). We provide proto files for streaming.proto and orderbook.proto.
Sub-millisecond latency with protobuf serialization and native zstd compression (~70% bandwidth reduction). Our nodes are deployed near Hyperliquid validators. Tokyo location recommended for lowest latency.
gRPC offers 9 streams vs 6 WebSocket streams. gRPC-exclusive: L2/L4 order book depth and Blocks. gRPC uses protobuf (3-10x smaller than JSON), supports bidirectional streaming, and has built-in zstd compression. WebSocket is simpler to integrate for standard real-time data. Both share the same 6 core streams: Trades, Orders, Book Updates, TWAP, Events, Writer Actions.
Yes. All streams support filtering by coin, side, user, and event type. This reduces bandwidth and processing overhead. Configure subscriptions to receive only the markets and events you need.
Yes, gRPC streaming is included in the RPC + gRPC plan at $200/month. Dedicated gRPC nodes with guaranteed resources and zero rate limits are also available.
Any language with gRPC support: Python, Go, Node.js, Rust, Java, C++, and more. We provide proto files (streaming.proto, orderbook.proto) and code examples to get started quickly.
Install grpcio and grpcio-tools, compile the proto files (streaming.proto, orderbook.proto), then create a gRPC channel to your endpoint on port 10000. Authenticate with x-token metadata and call StreamL2Book for aggregated price levels or StreamL4Book for individual order-level depth. We provide ready-to-use Python examples in our documentation.
StreamL2Book delivers aggregated order book data at each price level — total bid/ask size and depth. StreamL4Book provides individual order-level detail including order IDs, sizes, and timestamps. L2 is lighter and suits most trading strategies. L4 is for market makers and HFT systems that need full order book granularity. Both are gRPC-exclusive and not available via WebSocket.
Yes. Use the Trades stream for real-time fill data, Orders stream to track order lifecycle (18+ statuses), Book Updates for price movements, and Events for funding rates and liquidations. gRPC delivers data faster than REST polling and with less overhead than WebSocket, making it ideal for automated trading systems.
StreamData is a bidirectional gRPC method that supports 6 stream types: Trades (executed trades), Orders (order lifecycle events), Book Updates (L2 changes), TWAP (execution progress), Events (funding, liquidations), and Writer Actions (spot token transfers). You subscribe with filters and receive continuous real-time updates.
Not necessarily. Shared gRPC ($200/month with RPC) works well for development, testing, and moderate-volume trading bots. Dedicated gRPC nodes ($1800+/month) are recommended for HFT systems, market makers, and production workloads that need zero rate limits, isolated resources, and guaranteed performance under any load.
Subscribe to the Events stream via StreamData and filter by liquidation event type. You receive real-time notifications when positions are liquidated, including the asset, size, price, and affected account. This is used for liquidation bots, risk monitoring dashboards, and market analytics platforms.
SHORT INTEGRATION GUIDE
01
Register
Sign up and whitelist your IP
02
Connect gRPC
Configure gRPC endpoint in your app
03
Subscribe
Set up filters for order book, fills, or events
04
Stream
Receive real-time L1 data instantly