What is HyperCore?

HyperCore is Hyperliquid's native exchange layer. It maintains markets, order books, orders, positions, and the account state needed for trading. HyperEVM is the separate execution layer for smart contracts; see the HyperEVM overview when you need EVM blocks, transactions, or contract calls.

For spot markets, HIP-1 defines native fungible tokens and their spot order books. HIP-2 defines Hyperliquidity, an onchain liquidity strategy for those markets. These names describe different parts of spot trading, rather than separate API routes.

Applications usually interact with HyperCore in three ways:

• Read exchange state: Fetch market metadata, prices, order books, positions, and account information.
• Trade: Build, sign, and submit orders or manage existing ones.
• Follow activity: Subscribe to trades, order changes, and book updates as they happen, or query historical blocks to recover missed data.

Quicknode exposes these workflows through different APIs. Most use your Hyperliquid endpoint, but their paths, protocols, and request formats differ. Free trial users receive a shared URL for the Exchange API.

Quicknode services for HyperCore

Service	Use it for	Endpoint
Info API	Market and user state on demand	HTTP POST /info
Exchange API	Building and sending trades, order management, and market queries	REST paths under /hypercore
HyperCore JSON-RPC	Historical blocks and on-demand exchange queries	HTTP POST /hypercore
HyperCore gRPC	Low-latency streaming, including detailed order book feeds	gRPC on port 10000
HyperCore WebSocket	Live trades, orders, and other exchange events in a JSON stream	WSS /hypercore/ws

Use /info for a current snapshot, /hypercore to backfill available history, and WebSocket or gRPC to keep a live view updated. The Exchange API handles trading actions. For stream types, availability, and filters, see the Data Streams overview.

For account balances, use clearinghouseState for perpetual positions and spotClearinghouseState for spot balances. hl_batchPortfolioStates retrieves current portfolio states for multiple users. gRPC provides live activity, while HyperCore JSON-RPC retrieves historical blocks where available. Activity streams alone may not reconstruct every balance change; see balance reconciliation.

More ways to work with HyperCore data

The APIs above let your application request data or maintain a live connection. Quicknode also offers products for delivering, querying, or receiving HyperCore data through a node you run:

Product	What it provides	Use it when
Streams	HyperCore mainnet datasets for trades, orders, book updates, events, and more, delivered to a destination you configure	You need a managed data pipeline with filtering, backfill, or delivery to storage and applications
SQL Explorer	Indexed HyperCore history for fills, orders, funding, markets, and portfolios	You need historical analysis, reports, or a queryable data source for dashboards
Peering	Dedicated sentry peers that deliver raw blocks and the full mempool to a Hyperliquid node you operate	You run your own non-validating node and need its raw local data feed

Streams' HyperCore block dataset combines activity into a per-block payload; it is different from the raw replica_cmds block feed available through HyperCore gRPC and JSON-RPC. SQL Explorer uses its own query endpoint and API key. See each product's documentation for setup and access details.

Before you send a request

Create a Hyperliquid endpoint in the Quickstart and copy its provider URL. The examples below replace its path with the route for each service. HTTP and WebSocket URLs include your endpoint token; gRPC uses the endpoint hostname on port 10000 and passes the token as a bearer credential.

/info is available on all plans. HyperCore JSON-RPC, WebSocket, and gRPC require a Build plan or higher. Free trial users access the Exchange API through a shared URL. See Pricing & Plans for the current access rules.

How to use each service

HyperCore Info Endpoint

https://your-endpoint.hype-mainnet.quiknode.pro/your-token/info

Send an HTTP POST request with a type field identifying the information you want. Use it to retrieve market metadata, user positions, trading history, vault analytics, funding rates, portfolio data, and prices. For live order book or trade feeds, use the streaming services below.

Example request:

curl -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/info \
  -H "Content-Type: application/json" \
  -d '{
    "type": "allMids"
  }'

The Info Endpoints reference lists request types for market metadata, user data, orders, funding, and vaults.

HyperCore Method Compatibility

Quicknode's /info endpoint supports all 73 Hyperliquid info methods on every plan, including the free trial. This includes l2Book and recentTrades. For real-time updates on eligible plans, StreamL2Book delivers order book snapshots via gRPC, and StreamData provides a TRADES stream.

See the Info Endpoints reference for the full method list.

HyperCore Exchange API Endpoint

The Exchange API handles trading operations, builder fee management, and market queries. Build an action, sign its returned hash, then send the signed action. You can also validate an order before signing and discover available markets. See the Exchange API overview for the full build and send flow.

The trading route is /hypercore/exchange. Related REST routes such as /hypercore/markets and /hypercore/openOrders provide market and order data.

Available Method Categories:

• Build (no signature) - Build order actions that return hash to sign: orders, market orders, close position, cancel, modify, approve/revoke builder fee
• Send (with signature) - Submit signed actions to Hyperliquid: send order, cancel, modify, approval, revocation
• Enhanced Endpoints - Check approval status, query open orders with pre-built cancel actions, check order status with plain-English explanation, validate orders (preflight), list markets and DEXes

Example request (build order):

curl -s -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/exchange \
  -H "Content-Type: application/json" \
  -d '{
  "action": {
    "type": "order",
    "orders": [
      {
        "asset": "BTC",
        "side": "buy",
        "price": "100000",
        "size": "0.001",
        "tif": "ioc"
      }
    ]
  }
}'

Example request (list markets):

curl -s https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/markets

Example request (open orders):

curl -s -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/openOrders \
  -H "Content-Type: application/json" \
  -d '{
  "user": "0x8ae62e9a4775350022c1577b2eff694e2b72be8d"
}'

HyperCore HTTP/JSON-RPC Endpoint

https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore

Use JSON-RPC to retrieve available historical exchange data and run on-demand queries. It can backfill missed data after a streaming connection drops, fetch a block by number, or retrieve batches of blocks for analysis. Check the available history for the dataset you need before planning a full backfill.

Example request:

curl -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "hl_getLatestBlocks",
    "params": {
      "stream": "trades",
      "count": 10
    },
    "id": 1
  }'

HyperCore gRPC Streaming Endpoint

your-endpoint.hype-mainnet.quiknode.pro:10000

HyperCore gRPC provides low-latency, compressed streaming for trades, orders, events, raw blocks, and detailed order book feeds. Some feeds, such as L2 and L4 order book updates, are available only through gRPC. For a JSON-based connection in a browser, use WebSocket.

Use the endpoint hostname and port 10000, then authenticate with your endpoint token in gRPC metadata. A gRPC client also needs the protocol buffer definitions for the stream it subscribes to. The gRPC setup guides explain how to generate a client and subscribe to StreamData or an order book feed.

For example, a provider URL of https://your-endpoint.hype-mainnet.quiknode.pro/your-token/ becomes a gRPC connection to your-endpoint.hype-mainnet.quiknode.pro:10000 with your-token supplied as a bearer token.

HyperCore WebSocket Endpoint

wss://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/ws

Use WebSocket for a persistent JSON connection in a browser or JavaScript application. Subscribe to the streams you need with the full JSON-RPC envelope, including jsonrpc, method, params, and id.

Example subscription:

const ws = new WebSocket('wss://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/ws');

ws.addEventListener('open', () => {
  // Send the full JSON-RPC envelope after the connection opens.
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    method: 'hl_subscribe',
    params: {
      streamType: 'trades',
      filters: { coin: ['BTC', 'ETH'] }
    },
    id: 1
  }));
});

Explore the references

Info Endpoints

Find request types for market metadata, account state, orders, funding, and vaults.

Exchange API

Follow the build, sign, and send workflow for trades and order management.

HyperCore JSON-RPC

Look up historical blocks and run batch exchange-state queries.

WebSocket Subscriptions

Subscribe to live trades, orders, book updates, and other HyperCore events.

gRPC Methods

Explore typed streaming methods for trades, order books, blocks, and mempool data.

Data Streams

Compare stream types, protocol availability, and filtering options.