Docs
Docs
Home
Getting Started
Agent Tooling
CLI
Supported Chains
Acala
Aptos
Arbitrum
Arc
Asset Hub
Astar
Avalanche
Base
Berachain
Bifrost
Binance Smart Chain
Bittensor
Blast
Boba Network
Bridge Hub
Celo
Centrifuge
Chiliz
Cronos
Enjin
Ethereum
Etherlink
Flow EVM Gateway
Gnosis
Hydration
Hyperliquid
Immutable
Ink
IoTeX
Kusama
Linea
LISK
Manta Atlantic
Manta Pacific
Mantle
MegaETH
Monad
Movement
Neuroweb
opBNB
Optimism
Plasma
Polkadot
Polygon
Pulsechain
Robinhood
Ronin
Scroll
Sonic
Starknet
Taiko
Tempo
Sui
TRON
Unichain
Viction
World Chain
XDC Network
XX Network
Zetachain
zkSync Era
Zora
Supported ChainsHyperliquidHyperliquid HyperCoregRPC Streaming API

StreamTrades - Stream Normalized Trades

Subscribe to live normalized Hyperliquid trades for up to 20 coins with optional counterparty filtering over V3 gRPC.

Hyperliquid RPC endpoint: endpoint URLs, plans and pricing.

StreamTrades sends normalized executions in one batch per (block, coin). Within one block, identify a match by (coin, tid). Across blocks, include the batch's block_number in the match key.

A trade can contain multiple makers. Preserve every address in bid_users and ask_users.

Request and live-only behavior

coins is required and accepts 1 through 20 distinct, validated identifiers. Optional users keeps a trade when any counterparty matches case-insensitively. The coin and user filters combine using AND semantics.

The stream starts with executions observed after subscription. It has no opening snapshot or historical backfill. Per-coin order is preserved; ordering between coins is unspecified. A batch emptied by the user filter is dropped.

Go request
package main

import (
    "context"
    "crypto/tls"
    "log"
    "os"

    pb "example.com/hyperliquid-v3-client/gen/v3"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
)

func main() {
    endpoint, apiKey := os.Getenv("HYPERLIQUID_GRPC_ENDPOINT"), os.Getenv("DWELLIR_API_KEY")
    if endpoint == "" || apiKey == "" {
        log.Fatal("set HYPERLIQUID_GRPC_ENDPOINT and DWELLIR_API_KEY")
    }
    conn, err := grpc.NewClient(endpoint, grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{MinVersion: tls.VersionTLS12})))
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    ctx := metadata.AppendToOutgoingContext(context.Background(), "x-api-key", apiKey)
    stream, err := pb.NewMarketStreamingClient(conn).StreamTrades(ctx, &pb.TradesRequest{
        Coins: []string{"BTC", "ETH"},
        Users: []string{"0x1111111111111111111111111111111111111111"},
    })
    if err != nil {
        log.Fatal(err)
    }
    for {
        update, err := stream.Recv()
        if err != nil {
            log.Fatal(err)
        }
        for _, trade := range update.GetTrades() {
            log.Printf("block=%d coin=%s tid=%d side=%s px=%s sz=%s bid_users=%v ask_users=%v", update.GetBlockNumber(), trade.GetCoin(), trade.GetTid(), trade.GetSide(), trade.GetPx(), trade.GetSz(), trade.GetBidUsers(), trade.GetAskUsers())
        }
    }
}

Delivery and recovery

Trades do not carry a sequence. Frame loss or a stream state reset closes the stream with ABORTED; reconnecting resumes live delivery but does not recover missed executions. Use the raw fills stream, historical data, or an indexed product when durable recovery is required. Shared errors are documented on the gRPC overview.

Related reference: StreamAllFills.

StreamTpslUpdates - Stream TP/SL Order Updates

Reconstruct Hyperliquid take-profit and stop-loss trigger orders from typed snapshots and sequenced V3 gRPC diffs.

StreamAllFills - Stream All Fills

Subscribe to live per-account Hyperliquid fills across all or selected coins and users over the V3 gRPC API.

On this page

Request and live-only behaviorDelivery and recovery