Hyperliquid Info API

Available Types (today)

Type	Body	Returns
`metaAndAssetCtxs`	`{type:"metaAndAssetCtxs",dex:""}`	Tuple [meta, assetCtxs[]] - perp universe + per-asset mark, funding, OI, day volume
`meta`	`{type:"meta",dex:""}`	Perp universe metadata only - size decimals, max leverage, margin tiers (no live context)
`spotMetaAndAssetCtxs`	`{type:"spotMetaAndAssetCtxs"}`	Tuple [spotMeta, assetCtxs[]] - spot universe + per-pair mark, mid, day volume
`spotMeta`	`{type:"spotMeta"}`	Spot universe metadata only - pairs and the full token registry (no live context)
`outcomeMeta`	`{type:"outcomeMeta"}`	Active HIP-4 outcome universe with outcome IDs, descriptions, and Yes/No side specs
`l2Book`	`{type:"l2Book",coin:"BTC"}`	Aggregated Level-2 order book snapshot for one coin (bid/ask levels)
`candleSnapshot`	`{type:"candleSnapshot",req:{coin:"BTC",interval:"1h",startTime:...}}`	Historical OHLCV candles for a coin and interval over a time window
`fundingHistory`	`{type:"fundingHistory",coin:"BTC",startTime:...}`	Market-wide historical funding rates and premiums for a coin over a time window
`clearinghouseState`	`{type:"clearinghouseState",user:"0x...",dex:""}`	Perp account state
`spotClearinghouseState`	`{type:"spotClearinghouseState",user:"0x...",dex:""}`	Spot balances
`frontendOpenOrders`	`{type:"frontendOpenOrders",user:"0x...",dex:""}`	Open orders w/ TP/SL metadata
`subAccounts`	`{type:"subAccounts",user:"0x..."}`	Sub-accounts owned by a master, each with inlined perp and spot state
`userFills`	`{type:"userFills",user:"0x..."}`	Most recent fills for a user
`userFillsByTime`	`{type:"userFillsByTime",user:"0x...",startTime:...}`	Fills bounded by a time window
`userTwapSliceFills`	`{type:"userTwapSliceFills",user:"0x..."}`	Most recent TWAP slice fills tagged with parent `twapId`
`userFunding`	`{type:"userFunding",user:"0x...",startTime:...}`	Funding payment history with rate, applied size, USDC delta
`userNonFundingLedgerUpdates`	`{type:"userNonFundingLedgerUpdates",user:"0x...",startTime:...}`	Ledger events except funding - deposits, withdrawals, transfers, vault flows, liquidations
`userVaultEquities`	`{type:"userVaultEquities",user:"0x..."}`	Per-vault locked equity with unlock timestamps
`delegatorSummary`	`{type:"delegatorSummary",user:"0x..."}`	Current delegated, undelegated, pending-withdrawal HYPE totals
`delegatorHistory`	`{type:"delegatorHistory",user:"0x..."}`	Delegate, undelegate, deposit, and withdrawal staking events
`delegatorRewards`	`{type:"delegatorRewards",user:"0x..."}`	Accrued staking rewards (delegation and validator commission)
`batchClearinghouseState`	`{type:"batchClearinghouseState",users:["0x...",...],dex:""}`	Array of clearinghouseState slots, 1-50 wallets. GoldRush-native (no upstream equivalent)
`batchSpotClearinghouseState`	`{type:"batchSpotClearinghouseState",users:["0x...",...]}`	Array of spotClearinghouseState slots, 1-50 wallets. GoldRush-native (no upstream equivalent)

Any other type value returns {"error":"unsupported_type","type":"<the type you sent>"} with HTTP 400. Requests are not forwarded to upstream Hyperliquid.

Migration Pattern

// Before
fetch("https://api.hyperliquid.xyz/info", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(body),
});

// After -same body, no rate limits
fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});

The GoldRush Hyperliquid Info API is a drop-in replacement for POST https://api.hyperliquid.xyz/info. The request body, the response shape, and the JSON keys are byte-for-byte identical to the public Hyperliquid API. The only differences are the URL and the authentication header. Twenty-three wire-compatible type values are supported today across market metadata, user state, user history, vaults, and staking - plus four GoldRush-native types (two batched state lookups and two builder-keyed fill feeds) with no upstream equivalent.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Comparison with the public Hyperliquid API

	Public API	GoldRush
URL	`https://api.hyperliquid.xyz/info`	`https://hypercore.goldrushdata.com/info`
Auth	None	`Authorization: Bearer`
Rate limit	1200 weight/min/IP	None
Orderbook latency target	`p50`: `~280 ms`	`p50`: `"}` instead of being forwarded

Available types

The Info API supports the wire-compatible drop-in types below, organized by what they return. Four GoldRush-native types (batchClearinghouseState, batchSpotClearinghouseState, builderFills, builderFillsByTime) have no upstream Hyperliquid equivalent.

Market metadata

Type	Body	Returns
`metaAndAssetCtxs`	`{"type": "metaAndAssetCtxs", "dex": ""}`	Tuple `[meta, assetCtxs[]]` - perp universe + per-asset live mark price, funding, OI, day volume.
`meta`	`{"type": "meta", "dex": ""}`	Perp universe metadata only - size decimals, max leverage, margin tiers. No live context.
`spotMetaAndAssetCtxs`	`{"type": "spotMetaAndAssetCtxs"}`	Tuple `[spotMeta, assetCtxs[]]` - spot universe + per-pair live mark price, mid, day volume.
`spotMeta`	`{"type": "spotMeta"}`	Spot universe metadata only - pairs and the full token registry. No live context.
`outcomeMeta`	`{"type": "outcomeMeta"}`	Active HIP-4 outcome universe - integer outcome IDs, names, structured descriptions, and `sideSpecs` (`Yes` / `No`).
`l2Book`	`{"type": "l2Book", "coin": "BTC"}`	Aggregated Level-2 order book snapshot for one coin - bids and asks as `{px, sz, n}` levels.
`candleSnapshot`	`{"type": "candleSnapshot", "req": {"coin": "BTC", "interval": "1h", "startTime": …}}`	Historical OHLCV candles for a coin and interval over a time window.
`fundingHistory`	`{"type": "fundingHistory", "coin": "BTC", "startTime": …}`	Market-wide historical funding rates and premiums for a coin over a time window.

User account state

Type	Body	Returns
`clearinghouseState`	`{"type": "clearinghouseState", "user": "0x…", "dex": ""}`	Perp account: positions, margin summary, account value, withdrawable.
`spotClearinghouseState`	`{"type": "spotClearinghouseState", "user": "0x…", "dex": ""}`	Spot balances per token, total USD value.
`frontendOpenOrders`	`{"type": "frontendOpenOrders", "user": "0x…", "dex": ""}`	Open orders + trigger metadata (TP/SL, `isPositionTpsl`, `reduceOnly`, `orderType`).
`subAccounts`	`{"type": "subAccounts", "user": "0x…"}`	List of sub-accounts owned by a master, each with its inlined perp and spot state.

User history

Type	Body	Returns
`userFills`	`{"type": "userFills", "user": "0x…"}`	Most recent fills for a wallet (up to 2,000).
`userFillsByTime`	`{"type": "userFillsByTime", "user": "0x…", "startTime": …}`	Fills bounded by a time window.
`userTwapSliceFills`	`{"type": "userTwapSliceFills", "user": "0x…"}`	Most recent TWAP slice fills, each tagged with the parent `twapId`.
`userFunding`	`{"type": "userFunding", "user": "0x…", "startTime": …}`	Funding payment history with rate, applied size, and USDC delta per event.
`userNonFundingLedgerUpdates`	`{"type": "userNonFundingLedgerUpdates", "user": "0x…", "startTime": …}`	Ledger events except funding - deposits, withdrawals, transfers, vault flows, liquidations.

Vaults & staking

Type	Body	Returns
`userVaultEquities`	`{"type": "userVaultEquities", "user": "0x…"}`	Per-vault locked equity with unlock timestamps.
`delegatorSummary`	`{"type": "delegatorSummary", "user": "0x…"}`	Current delegated, undelegated, and pending-withdrawal HYPE totals.
`delegatorHistory`	`{"type": "delegatorHistory", "user": "0x…"}`	Delegate, undelegate, deposit, and withdrawal staking events.
`delegatorRewards`	`{"type": "delegatorRewards", "user": "0x…"}`	Accrued staking rewards (delegation and validator commission).

Builder activity

Type	Body	Returns
`builderFills`	`{"type": "builderFills", "builder": "0x…"}`	Most recent fills attributed to a builder address (up to 2,000). GoldRush-native, no upstream equivalent.
`builderFillsByTime`	`{"type": "builderFillsByTime", "builder": "0x…", "startTime": …}`	Builder-attributed fills bounded by a time window. GoldRush-native, no upstream equivalent.

GoldRush-native batch

Type	Body	Returns
`batchClearinghouseState`	`{"type": "batchClearinghouseState", "users": ["0x…", …], "dex": ""}`	Array of `clearinghouseState` slots. GoldRush-native, 1 to 50 wallets per call.
`batchSpotClearinghouseState`	`{"type": "batchSpotClearinghouseState", "users": ["0x…", …]}`	Array of `spotClearinghouseState` slots. GoldRush-native, 1 to 50 wallets per call.

If you send a type that isn’t in the table above, the response body is {"error":"unsupported_type","type":""}. Requests are not forwarded to upstream Hyperliquid.

How clients see it

Existing Hyperliquid SDKs work unchanged after a baseUrl override. See SDK compatibility for nomeida/hyperliquid (JS) and hyperliquid-dex/hyperliquid-python-sdk setup snippets.

Errors

Status	Body	Cause
`400`	`{"error":"invalid request"}`	Malformed body.
`400`	`{"error":"unsupported_type","type":""}`	The `type` field isn’t one of the natively-supported types.
`401`	`{"error":"unauthorized"}`	Missing or invalid `Authorization` header.
`429`	n/a	Not returned. GoldRush has no per-IP rate limit on `/info` - any retry logic you carried over from `api.hyperliquid.xyz` can stay in place but won’t fire.
`5xx`	Server error	Internal server error.

Networks

Mainnet only. Testnet support is deferred.

Migration guide

Side-by-side examples - change one URL and one header.

SDK compatibility

Drop-in setup for nomeida/hyperliquid and hyperliquid-python-sdk.

Limits and caching

No rate limits - what to know about caching and recommended polling cadences.

API reference

Per-endpoint request and response schemas.

Moving from the public Hyperliquid /info API to GoldRush is two changes:

URL - replace api.hyperliquid.xyz/info with hypercore.goldrushdata.com/info.
Header - add Authorization: Bearer .

That’s it. The request body and response shape are byte-for-byte identical.

Side-by-side

cURL

Public Hyperliquid

curl -X POST https://api.hyperliquid.xyz/info \
  -H "Content-Type: application/json" \
  -d '{
    "type": "clearinghouseState",
    "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    "dex": ""
  }'

GoldRush

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "clearinghouseState",
    "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    "dex": ""
  }'

JavaScript / TypeScript

Public Hyperliquid

const response = await fetch("https://api.hyperliquid.xyz/info", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    type: "metaAndAssetCtxs",
    dex: "",
  }),
});

const data = await response.json();

GoldRush

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "metaAndAssetCtxs",
    dex: "",
  }),
});

const data = await response.json();

Python

Public Hyperliquid

import requests

response = requests.post(
    "https://api.hyperliquid.xyz/info",
    json={
        "type": "spotClearinghouseState",
        "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
        "dex": "",
    },
)

print(response.json())

GoldRush

import os
import requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "spotClearinghouseState",
        "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
        "dex": "",
    },
)

print(response.json())

Behavioral notes

Things to be aware of when you cut over.

Response is byte-equal, modulo live drift

For implemented types, the response body matches Hyperliquid byte-for-byte - same keys, same nesting, same value types. Numeric fields update independently on each side, so a market-price field will diverge by tens of milliseconds, but the schema is identical.

Unsupported types return a JSON error

Types that GoldRush doesn’t natively serve return {"error":"unsupported_type","type":""} with HTTP 400. They are not forwarded to upstream Hyperliquid. See the Info API overview for the current list of supported types.

Auth errors return JSON

A missing or invalid key returns 401 with body {"error":"unauthorized"}. Public Hyperliquid has no auth and never returns 401.

Existing SDKs work after a `baseUrl` override

The two most-used SDKs work unchanged:

nomeida/hyperliquid (JavaScript)
hyperliquid-dex/hyperliquid-python-sdk (Python)

See SDK compatibility for the override snippets.

Authentication

The Info API uses your standard GoldRush API key. The same key works against the Foundational API, the Streaming API, and the Pipeline API. If you don’t have one yet, sign up here. Never hardcode keys in source. Use environment variables or a secrets manager.

What you gain

No rate limits. No 1200 weight/min cap, no per-address throttling, no IP buckets.
Faster reads. Sub-150 ms p50 target for warm responses; orderbook reads driven from a live WebSocket-fed cache.
More types. Batched user state, builder-attribution data, liquidation feed, and composites.
HIP-3 and HIP-4 first-class. Deployer-prefix syntax (xyz:GOLD-USDC) is supported across meta and metaAndAssetCtxs when a dex is provided.
One key for everything Hyperliquid. The same API key unlocks Streaming, Pipeline, and HyperEVM via the Foundational API.

The most popular Hyperliquid SDKs work against GoldRush after a one-line baseUrl override and adding an Authorization header.

JavaScript / TypeScript: `nomeida/hyperliquid`

Install

npm

npm install hyperliquid

yarn

yarn add hyperliquid

Configure

import { Hyperliquid } from "hyperliquid";

const sdk = new Hyperliquid({
  // Point at GoldRush
  baseUrl: "https://hypercore.goldrushdata.com",
  // Inject the Authorization header on every request
  headers: {
    Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
  },
});

// Existing methods work unchanged
const ctxs = await sdk.info.metaAndAssetCtxs();
const account = await sdk.info.clearinghouseState({
  user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
});
const spot = await sdk.info.spotClearinghouseState({
  user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
});
const orders = await sdk.info.frontendOpenOrders({
  user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
});

Note: If your SDK version doesn’t expose a headers option, wrap fetch to inject the header globally before instantiating the SDK. See the patch pattern below.

Header injection fallback

const originalFetch = globalThis.fetch;
globalThis.fetch = (input, init = {}) => {
  const headers = new Headers(init.headers);
  if (typeof input === "string" && input.startsWith("https://hypercore.goldrushdata.com")) {
    headers.set("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);
  }
  return originalFetch(input, { ...init, headers });
};

Python: `hyperliquid-dex/hyperliquid-python-sdk`

Install

pip install hyperliquid-python-sdk

Configure

import os
from hyperliquid.info import Info

# Point Info at GoldRush
info = Info(base_url="https://hypercore.goldrushdata.com", skip_ws=True)

# Inject the Authorization header on the underlying session
info.session.headers.update({
    "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"
})

# Existing methods work unchanged
ctxs = info.meta_and_asset_ctxs()
account = info.user_state("0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00")
spot = info.spot_user_state("0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00")
orders = info.frontend_open_orders("0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00")

Tip: skip_ws=True is recommended when using the Info API only - it skips the WebSocket connection that the SDK opens by default to upstream Hyperliquid. For real-time event streams, use the GoldRush Streaming API instead.

Verification

After cutover, confirm everything is wired correctly:

Diff a known wallet - call clearinghouseState for the same wallet against both endpoints; the JSON shape (keys, nesting, types) should match exactly.
Confirm auth - remove the API key and confirm you get a 401 with body {"error":"unauthorized"}. If you get any other response, your request isn’t reaching GoldRush.

Other SDKs

The pattern is the same for any HTTP client: override the base URL to https://hypercore.goldrushdata.com and attach Authorization: Bearer . If you run into a specific SDK that doesn’t expose either knob, email us - we’ll publish a recipe.

No rate limits

The GoldRush Hyperliquid Info API has no per-IP, per-key, or per-address rate limits. The 1200 weight/min cap on the public Hyperliquid /info API does not apply. You can:

Poll any user-state endpoint as fast as your code wants.
Open as many concurrent connections as your client supports.
Pull state for thousands of wallets in tight loops.

For wallet-level real-time updates without polling at all, use the Streaming API walletTxs subscription instead - push-based, also no rate limits.

How caching works

Responses are served from a real-time cache that’s kept fresh by direct ingestion from Hyperliquid. The cache is transparent to your client code - same JSON in, same JSON out.

Cache layer	Typical freshness
User-state types (`clearinghouseState`, `spotClearinghouseState`, `frontendOpenOrders`)	Sub-second after each user event.
Market types (`metaAndAssetCtxs`)	Sub-second on every mark-price tick.

Recommended polling cadences

You’re not rate-limited, but polling smartly saves your own bandwidth.

Endpoint	Recommended interval	Notes
`metaAndAssetCtxs`	1 second	Mark prices update on every tick - for sub-second freshness, use the Streaming API.
`clearinghouseState`	1 second per user, OR push via `walletTxs`	Account state only changes on a user event; push is far more efficient than polling.
`spotClearinghouseState`	5 seconds	Spot balances change less frequently than perp positions.
`frontendOpenOrders`	1 second per user, OR push via `walletTxs`	Same as `clearinghouseState`.

Watch out for client-side limits

GoldRush has no rate limits, but the rest of your stack might:

Browser fetch concurrency - most browsers cap at ~6 concurrent requests per host. Use connection pooling on the server side or batch requests.
HTTP/2 stream limits - most clients allow 100+ concurrent streams per connection by default. Bump if you’re saturating.
OS file descriptor limits - if you’re opening thousands of connections, raise ulimit -n.

For multi-wallet fan-out, use the batchClearinghouseState and batchSpotClearinghouseState endpoints, which accept up to 50 wallets per call. For more than 50 wallets, issue multiple calls.

Network and TLS

HTTP/2 keep-alive is supported and recommended.
TLS 1.2+ required.
Accept-Encoding: gzip is honored. zstd support is on the roadmap.

Need higher guarantees?

Enterprise SLA, dedicated capacity, regional pinning, and on-prem options are all available. Email sales.

Hyperliquid Info API Reference

batchClearinghouseState | Hyperliquid Info API

Credit Cost: 25 per call Processing: Realtime The Hyperliquid info endpoint with type: "batchClearinghouseState" is used to fetch perpetuals account state for up to 50 wallets in a single request.

Note: - No upstream equivalent. This endpoint exists only on hypercore.goldrushdata.com. It is not a passthrough.

Deduplication is case-insensitive. Two addresses that differ only in case (0xAbC... vs 0xabc...) collapse to a single slot in the output, at the position of the first occurrence in the input.
Order preservation. The order of slots in the response matches the order of unique wallets in the input.
Partial failure is normal. HTTP 200 OK is returned even when individual slots are error envelopes. Always check for the error key on each slot before using its fields.
No cursor or pagination. All requested wallets are fanned out in parallel. For batches larger than 50, issue multiple calls.
Use cases: portfolio dashboards, multi-wallet PnL aggregators, fleet-level liquidation risk monitoring, copy-trade source-wallet inventory.

Fetches perpetuals account state for 1 to 50 wallets in a single request. The standard Hyperliquid /info API is single-wallet, so polling N wallets means N round trips; this endpoint fans them out in parallel against our private node and returns a single combined response. This is a GoldRush-native extension. There is no equivalent on api.hyperliquid.xyz/info. The wrapped slots return exactly the same shape as Hyperliquid’s native single-wallet clearinghouseState, with a thin per-wallet error envelope when an individual wallet fails.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"batchClearinghouseState"`.
`users`	`array`	Yes	List of wallet addresses to query. 1 to 50 entries. Duplicates are removed (case-insensitive); input order is preserved for the surviving entries.
`dex`	`string`	No	Optional perpetuals DEX name. Forwarded unchanged to each per-wallet upstream call. Omit for the primary DEX.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "batchClearinghouseState",
    "users": [
      "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
      "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
      "0x31ca8395cf837de08b24da3f660e77761dfb974b"
    ]
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "batchClearinghouseState",
    users: [
      "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
      "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
      "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    ],
  }),
});

const slots = await response.json();

for (const [i, slot] of slots.entries()) {
  if ("error" in slot) {
    console.warn(`wallet ${slot.user} failed: ${slot.message}`);
    continue;
  }
  console.log(`wallet ${i}: ${slot.withdrawable} USD withdrawable`);
}

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "batchClearinghouseState",
        "users": [
            "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
            "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
            "0x31ca8395cf837de08b24da3f660e77761dfb974b",
        ],
    },
)

slots = response.json()

for i, slot in enumerate(slots):
    if "error" in slot:
        print(f"wallet {slot['user']} failed: {slot['message']}")
        continue
    print(f"wallet {i}: {slot['withdrawable']} USD withdrawable")

Response

HTTP/2 200 OK
Content-Type: application/json

The body is a JSON array. Element i corresponds to the i-th unique wallet in the deduplicated input order. Each element is either:

The raw upstream Hyperliquid response object for that wallet (success), or
A slot-level error object (failure for that wallet only, see below).

All success

Example success body for batchClearinghouseState with 3 wallets: one empty account, one with a single cross-margin position, one with a single isolated-margin position.

[
  {
    "user":               "0x.....",
    "marginSummary":      {"accountValue":"0.0","totalNtlPos":"0.0","totalRawUsd":"0.0","totalMarginUsed":"0.0"},
    "crossMarginSummary": {"accountValue":"0.0","totalNtlPos":"0.0","totalRawUsd":"0.0","totalMarginUsed":"0.0"},
    "crossMaintenanceMarginUsed": "0.0",
    "withdrawable": "0.0",
    "assetPositions": [],
    "time": 1777671895013
  },
  {
    "user":               "0x.....",
    "marginSummary":      {"accountValue":"28.848558","totalNtlPos":"134.30367","totalRawUsd":"163.152228","totalMarginUsed":"22.383945"},
    "crossMarginSummary": {"accountValue":"28.848558","totalNtlPos":"134.30367","totalRawUsd":"163.152228","totalMarginUsed":"22.383945"},
    "crossMaintenanceMarginUsed": "6.715183",
    "withdrawable": "6.464613",
    "assetPositions": [
      {
        "type": "oneWay",
        "position": {
          "coin": "SUI",
          "szi": "-145.8",
          "leverage": { "type": "cross", "value": 6 },
          "entryPx": "0.91652",
          "positionValue": "134.30367",
          "unrealizedPnl": "-0.674997",
          "returnOnEquity": "-0.0303077319",
          "liquidationPx": "1.0657275328",
          "marginUsed": "22.383945",
          "maxLeverage": 10,
          "cumFunding": { "allTime": "0.348217", "sinceOpen": "0.234102", "sinceChange": "0.206894" }
        }
      }
    ],
    "time": 1777671895076
  },
  {
    "user":               "0x.....",
    "marginSummary":      {"accountValue":"681.226963","totalNtlPos":"1353.54306","totalRawUsd":"-672.316097","totalMarginUsed":"681.226963"},
    "crossMarginSummary": {"accountValue":"0.0","totalNtlPos":"0.0","totalRawUsd":"0.0","totalMarginUsed":"0.0"},
    "crossMaintenanceMarginUsed": "0.0",
    "withdrawable": "0.0",
    "assetPositions": [
      {
        "type": "oneWay",
        "position": {
          "coin": "BTC",
          "szi": "0.01734",
          "leverage": { "type": "isolated", "value": 2, "rawUsd": "-672.316097" },
          "entryPx": "77441.3",
          "positionValue": "1353.54306",
          "unrealizedPnl": "10.710288",
          "returnOnEquity": "0.0159517823",
          "liquidationPx": "39263.3464441622",
          "marginUsed": "681.226963",
          "maxLeverage": 40,
          "cumFunding": { "allTime": "0.326319", "sinceOpen": "0.271556", "sinceChange": "-0.026742" }
        }
      }
    ],
    "time": 1777671895076
  }
]

Mixed result (one wallet failed)

When a single wallet fails (upstream timeout, transport failure, parse failure, etc.), only its slot is replaced with an error object. The rest of the batch is unaffected. The HTTP status is still 200 OK.

[
  { "withdrawable": "13104.514502", "...": "..." },
  {
    "error": "upstream_error",
    "user": "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
    "message": "overall batch timeout exceeded"
  },
  { "withdrawable": "0.0", "...": "..." }
]

Per-wallet error slot

Field	Type	Description
`error`	`string`	Always `"upstream_error"` for slot-level failures. Distinguishes error slots from success slots, which never have a top-level `error` field.
`user`	`string`	The exact wallet address (lowercased) whose slot this is. Lets you correlate even if you didn’t track input order.
`message`	`string`	Human-readable description: `upstream_error:` , `upstream returned HTTP` , `overall batch timeout exceeded`, or similar.

clearinghouseState slot field reference

Each success slot mirrors Hyperliquid’s native clearinghouseState response: assetPositions[], crossMarginSummary, marginSummary, crossMaintenanceMarginUsed, time, withdrawable. There is no schema imposition - it’s the raw upstream object. For full per-field types and notes (including the two leverage shapes and the nullable liquidationPx), see the single-wallet endpoint:

clearinghouseState field reference

Full request and response schema for the single-wallet variant. The batch endpoint returns the same object per slot. For the canonical upstream documentation, see Hyperliquid’s Perpetuals info docs.

batchSpotClearinghouseState

fetch spot account balances for up to 50 wallets in a single request.

clearinghouseState

fetch a single user’s perpetuals account state by wallet address.

spotClearinghouseState

fetch a single user’s spot account balances by wallet address. Last reviewed: 2026-06-13

batchSpotClearinghouseState | Hyperliquid Info API

Credit Cost: 25 per call Processing: Realtime The Hyperliquid info endpoint with type: "batchSpotClearinghouseState" is used to fetch spot account balances for up to 50 wallets in a single request.

Note: - No upstream equivalent. This endpoint exists only on hypercore.goldrushdata.com. It is not a passthrough.

Deduplication is case-insensitive. Two addresses that differ only in case collapse to a single slot at the position of the first occurrence in the input.
Order preservation. Slots in the response are in the order of unique wallets in the input.
Partial failure is normal. HTTP 200 OK is returned even when individual slots are error envelopes. Always check for the error key on each slot before using its fields.
No cursor or pagination. All requested wallets are fanned out in parallel. For batches larger than 50, issue multiple calls.
Use cases: token treasury monitoring, holder analytics, balance reconciliation, multi-wallet airdrop eligibility checks.

Fetches spot account state for 1 to 50 wallets in a single request. The standard Hyperliquid /info API is single-wallet; this endpoint fans the requests out in parallel against our private node and returns a combined response. This is a GoldRush-native extension. There is no equivalent on api.hyperliquid.xyz/info. The wrapped slots return exactly the same shape as Hyperliquid’s native single-wallet spotClearinghouseState, with a thin per-wallet error envelope when an individual wallet fails.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"batchSpotClearinghouseState"`.
`users`	`array`	Yes	List of wallet addresses to query. 1 to 50 entries. Duplicates are removed (case-insensitive); input order is preserved for the surviving entries.
`dex`	`string`	No	Reserved for future HIP-3 spot DEX support. Pass empty string or omit.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "batchSpotClearinghouseState",
    "users": [
      "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
      "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc"
    ]
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "batchSpotClearinghouseState",
    users: [
      "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
      "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
    ],
  }),
});

const slots = await response.json();

for (const [i, slot] of slots.entries()) {
  if ("error" in slot) {
    console.warn(`wallet ${slot.user} failed: ${slot.message}`);
    continue;
  }
  console.log(`wallet ${i}: ${slot.balances.length} tokens`);
}

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "batchSpotClearinghouseState",
        "users": [
            "0xb0a55f13d22f66e6d495ac98113841b2326e9540",
            "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
        ],
    },
)

slots = response.json()

for i, slot in enumerate(slots):
    if "error" in slot:
        print(f"wallet {slot['user']} failed: {slot['message']}")
        continue
    print(f"wallet {i}: {len(slot['balances'])} tokens")

Response

HTTP/2 200 OK
Content-Type: application/json

The body is a JSON array. Element i corresponds to the i-th unique wallet in the deduplicated input order. Each element is either:

The raw upstream Hyperliquid response object for that wallet (success), or
A slot-level error object (failure for that wallet only, see below).

All success

Example success body for batchSpotClearinghouseState with 3 wallets: one empty wallet, one with a single USDC balance, one with multiple tokens including held amounts.

[
  {
    "user": "0x.....",
    "balances": [] },
  {
    "user": "0x.....",
    "balances": [
      { "coin": "USDC",  "token": 0,   "total": "0.001124", "hold": "0.0", "entryNtl": "0.0" },
      { "coin": "USDE",  "token": 235, "total": "0.0",      "hold": "0.0", "entryNtl": "0.0" },
      { "coin": "USDT0", "token": 268, "total": "0.0",      "hold": "0.0", "entryNtl": "0.0" },
      { "coin": "USDH",  "token": 360, "total": "0.0",      "hold": "0.0", "entryNtl": "0.0" }
    ],
    "tokenToAvailableAfterMaintenance": [[0, "0.001124"]]
  },
  {
    "user": "0x.....",
    "balances": [
      { "coin": "USDC", "token": 0,   "total": "129411.68874505", "hold": "73888.84763", "entryNtl": "0.0" },
      { "coin": "HYPE", "token": 150, "total": "959.37146013",    "hold": "0.0",         "entryNtl": "33092.4684" },
      { "coin": "UBTC", "token": 197, "total": "0.2104009544",    "hold": "0.0",         "entryNtl": "16128.2486005" },
      { "coin": "UETH", "token": 221, "total": "20.87812637",     "hold": "7.0018",      "entryNtl": "49605.34810641" }
    ]
  }
]

Mixed result (one wallet failed)

[
  { "balances": [...] },
  {
    "error": "upstream_error",
    "user": "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc",
    "message": "overall batch timeout exceeded"
  }
]

Per-wallet error slot

Field	Type	Description
`error`	`string`	Always `"upstream_error"` for slot-level failures. Distinguishes error slots from success slots, which never have a top-level `error` field.
`user`	`string`	The exact wallet address (lowercased) whose slot this is. Lets you correlate even if you didn’t track input order.
`message`	`string`	Human-readable description: `upstream_error:` , `upstream returned HTTP` , `overall batch timeout exceeded`, or similar.

spotClearinghouseState slot field reference

Each success slot mirrors Hyperliquid’s native spotClearinghouseState response: balances[] plus the optional tokenToAvailableAfterMaintenance field. There is no schema imposition - it’s the raw upstream object. The tokenToAvailableAfterMaintenance field is optional and only present when at least one token has a non-zero margin-deduction-aware balance. Wallets without this field can simply ignore it; absence is normal for empty or inactive wallets. For full per-field types and notes, see the single-wallet endpoint:

spotClearinghouseState field reference

Full request and response schema for the single-wallet variant. The batch endpoint returns the same object per slot. For the canonical upstream documentation, see Hyperliquid’s Spot info docs.

batchClearinghouseState

fetch perpetuals account state for up to 50 wallets in a single request.

spotClearinghouseState

fetch a single user’s spot account balances by wallet address.

clearinghouseState

fetch a single user’s perpetuals account state by wallet address.

spotMeta

fetch the spot universe metadata and full token configuration without live market context. Last reviewed: 2026-05-21

builderFillsByTime | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "builderFillsByTime" is used to fetch a builder’s attributed trade fills within a time window for revenue attribution and fee accounting.

Note: - GoldRush-native: No POST api.hyperliquid.xyz/info equivalent. Available only via POST hypercore.goldrushdata.com/info.

Each response contains at most 2,000 fills; widen the window in chunks or page by advancing startTime if you need more.
GoldRush serves this type from a dedicated HyperCore historical store, so windows can extend back to GoldRush’s full HyperCore coverage.
Use builderFills (no Time suffix) when you only need the most recent N fills without specifying a window.
For real-time push instead of windowed polling, subscribe to walletTxs and read HypercoreFillTransaction events.

Returns fills attributed to a builder address bounded by a [startTime, endTime] window in milliseconds. Use this for builder revenue reports, monthly fee reconciliation, or rebuilding historical builder order-flow. Builder-keyed. GoldRush-native as there is no upstream Hyperliquid /info equivalent. Served from a dedicated HyperCore historical store, so windows can extend back to GoldRush’s full HyperCore coverage.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"builderFillsByTime"`.
`builder`	`string`	Yes	The builder address that orders were routed through. Must be a `0x`-prefixed 42-character hex address.
`startTime`	`int`	Yes	Unix timestamp in milliseconds. Inclusive lower bound. Required unless `cursor` is supplied.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.
`aggregateByTime`	`boolean`	No	When `true`, partial fills sharing the same timestamp are consolidated into one row. Default `false`.
`cursor`	`string`	No	Pagination cursor - a Unix timestamp in milliseconds encoded as a string. When set, returns fills strictly before this time and overrides `startTime`. Use the `time` value of the oldest fill in the previous page to fetch the next page.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "builderFillsByTime",
    "builder": "0x0000000000000000000000000000000000000000",
    "startTime": 1781000000000
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "builderFillsByTime",
    builder: "0x0000000000000000000000000000000000000000",
    startTime: 1781000000000,
  }),
});

const fills = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "builderFillsByTime",
        "builder": "0x0000000000000000000000000000000000000000",
        "startTime": 1781000000000,
    },
)

fills = response.json()

Response

An array of fill objects ordered by time. Each entry is a fill from an order that was routed through the builder address within the window.

[
  {
    "user": "0x73f9c53a8b15e43056d5599f6488ac9a8730f85d",
    "coin": "HYPE",
    "px": "66.977",
    "sz": "0.69",
    "side": "B",
    "time": 1781518798259,
    "startPosition": "0",
    "dir": "Open Long",
    "closedPnl": "0",
    "hash": "0x2b7bd2df9499dfef2cf5043dc500b402068500c52f9cfec1cf447e32539db9d9",
    "oid": 469533808540,
    "crossed": true,
    "fee": "0.048524",
    "tid": 332575399132451,
    "feeToken": "USDC",
    "builderFee": "0.027728",
    "cloid": "0xff8ffaa775354e8faf1eaa18127d6b5e"
  }
]

Field descriptions

Note: All numeric fields (px, sz, startPosition, closedPnl, fee, builderFee) are returned as decimal strings with full upstream precision (up to 18 decimal places). Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`user`	`string`	The trader’s wallet address - the account that placed the order routed through the builder code.
`coin`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`); HIP-3 markets use the deployer-prefixed form.
`px`	`string`	Fill execution price.
`sz`	`string`	Fill size.
`side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`time`	`int`	Unix timestamp in milliseconds when the fill executed.
`startPosition`	`string`	Signed position size the trader held on this coin immediately before this fill.
`dir`	`string`	Human-readable direction label - `"Open Long"`, `"Open Short"`, `"Close Long"`, `"Close Short"`, `"Buy"`, `"Sell"`, or position-flip labels `"Long > Short"` / `"Short > Long"`.
`closedPnl`	`string`	Realized PnL in USDC attributable to this fill for the trader (zero when the fill opens or extends a position).
`hash`	`string`	L1 transaction hash that included this fill.
`oid`	`int`	Parent order ID.
`tid`	`int`	Unique trade ID.
`crossed`	`boolean`	`true` when the fill came from the taker side of the order, `false` when it was the maker side.
`fee`	`string`	Trading fee paid by the trader for this fill, denominated in `feeToken`.
`feeToken`	`string`	Symbol the fee was paid in - typically `"USDC"`.
`builderFee`	`string`	Optional. Builder fee earned for this fill, denominated in `feeToken`. Omitted when no builder fee was charged.
`cloid`	`string`	Optional. Client order ID (`0x`-prefixed 32-character hex) if one was set at order placement.
`liquidation`	`object`	Optional. Present only when this fill closed a position as part of a liquidation event.
`liquidation.liquidatedUser`	`string`	The wallet whose position was liquidated.
`liquidation.markPx`	`string`	Mark price at the time of liquidation.
`liquidation.method`	`string`	Liquidation method - e.g. `"Market"`.

builderFills

fetch a builder’s most recent attributed trade fills for revenue attribution and order-flow analytics.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

userFills

fetch a user’s most recent trade fills without specifying a time window.

userTwapSliceFills

fetch a user’s most recent TWAP slice fills for execution-quality analytics on algorithmic orders. Last reviewed: 2026-06-16

builderFills | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "builderFills" is used to fetch a builder’s most recent attributed trade fills for revenue attribution and order-flow analytics.

Note: - GoldRush-native: No POST api.hyperliquid.xyz/info equivalent. Available only via POST hypercore.goldrushdata.com/info.

Each response contains at most 2,000 fills, ordered most-recent first.
For windowed queries for revenue reports and monthly reconciliation, use builderFillsByTime.
For real-time push instead of windowed polling, subscribe to walletTxs and read HypercoreFillTransaction events.

Returns the 2,000 most recent fills attributed to a builder address. Use this when you operate a builder code and want to inspect the order flow routed through it without specifying a time window. Builder-keyed. GoldRush-native so there is no upstream Hyperliquid /info equivalent.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"builderFills"`.
`builder`	`string`	Yes	The builder address that orders were routed through. Must be a `0x`-prefixed 42-character hex address.
`aggregateByTime`	`boolean`	No	When `true`, partial fills sharing the same timestamp are consolidated into one row. Default `false`.
`cursor`	`string`	No	Pagination cursor — a Unix timestamp in milliseconds encoded as a string. When set, returns fills strictly before this time. Use the `time` value of the oldest fill in the previous page to fetch the next page.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "builderFills",
    "builder": "0x0000000000000000000000000000000000000000"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "builderFills",
    builder: "0x0000000000000000000000000000000000000000",
  }),
});

const fills = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "builderFills",
        "builder": "0x0000000000000000000000000000000000000000",
    },
)

fills = response.json()

Response

An array of fill objects ordered most-recent-first. Each entry is a fill from an order that was routed through the builder address.

[
  {
    "user": "0x73f9c53a8b15e43056d5599f6488ac9a8730f85d",
    "coin": "HYPE",
    "px": "66.977",
    "sz": "0.69",
    "side": "B",
    "time": 1781518798259,
    "startPosition": "0",
    "dir": "Open Long",
    "closedPnl": "0",
    "hash": "0x2b7bd2df9499dfef2cf5043dc500b402068500c52f9cfec1cf447e32539db9d9",
    "oid": 469533808540,
    "crossed": true,
    "fee": "0.048524",
    "tid": 332575399132451,
    "feeToken": "USDC",
    "builderFee": "0.027728",
    "cloid": "0xff8ffaa775354e8faf1eaa18127d6b5e"
  }
]

Field descriptions

Note: All numeric fields (px, sz, startPosition, closedPnl, fee, builderFee) are returned as decimal strings with full upstream precision (up to 18 decimal places). Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`user`	`string`	The trader’s wallet address - the account that placed the order routed through the builder code.
`coin`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`); HIP-3 markets use the deployer-prefixed form.
`px`	`string`	Fill execution price.
`sz`	`string`	Fill size.
`side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`time`	`int`	Unix timestamp in milliseconds when the fill executed.
`startPosition`	`string`	Signed position size the trader held on this coin immediately before this fill.
`dir`	`string`	Human-readable direction label - `"Open Long"`, `"Open Short"`, `"Close Long"`, `"Close Short"`, `"Buy"`, `"Sell"`, or position-flip labels `"Long > Short"` / `"Short > Long"`.
`closedPnl`	`string`	Realized PnL in USDC attributable to this fill for the trader (zero when the fill opens or extends a position).
`hash`	`string`	L1 transaction hash that included this fill.
`oid`	`int`	Parent order ID.
`tid`	`int`	Unique trade ID.
`crossed`	`boolean`	`true` when the fill came from the taker side of the order, `false` when it was the maker side.
`fee`	`string`	Trading fee paid by the trader for this fill, denominated in `feeToken`.
`feeToken`	`string`	Symbol the fee was paid in - typically `"USDC"`.
`builderFee`	`string`	Optional. Builder fee earned for this fill, denominated in `feeToken`. Omitted when no builder fee was charged.
`cloid`	`string`	Optional. Client order ID (`0x`-prefixed 32-character hex) if one was set at order placement.
`liquidation`	`object`	Optional. Present only when this fill closed a position as part of a liquidation event.
`liquidation.liquidatedUser`	`string`	The wallet whose position was liquidated.
`liquidation.markPx`	`string`	Mark price at the time of liquidation.
`liquidation.method`	`string`	Liquidation method - e.g. `"Market"`.

userFills

fetch a user’s most recent trade fills without specifying a time window.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

userTwapSliceFills

fetch a user’s most recent TWAP slice fills for execution-quality analytics on algorithmic orders. Last reviewed: 2026-06-16

candleSnapshot | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "candleSnapshot" is used to fetch historical OHLCV candles for a coin and interval over a time window for charting and backtesting.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "candleSnapshot", "req": {...}}. Note the nested req object.

Each response contains at most 5,000 candles (per-response cap, not a retention limit); page by advancing startTime for longer ranges.
GoldRush serves candles from a dedicated HyperCore historical store, so candles older than the upstream window can extend back to GoldRush’s full HyperCore coverage.
For live, push-based candles, including HIP-3 and HIP-4 markets, use the Streaming API OHLCV streams instead of polling.

Returns an array of OHLCV candles for a single coin and interval, bounded by a [startTime, endTime] window. Each candle carries the open/close timestamps, the coin, the interval, open/high/low/close prices, base volume, and trade count. Use it for chart backfills, indicator computation, and backtests. This is a global, non-user-keyed type. NOT LIMITED TO THE MOST RECENT 5,000 CANDLES. GoldRush serves it from a dedicated HyperCore historical store so candles older than the upstream window remain available; page through time by advancing startTime.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

The request parameters are nested inside a req object.

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"candleSnapshot"`.
`req`	`object`	Yes	The candle query parameters. The asset symbol, e.g. `"BTC"`. HIP-3 markets use the deployer-prefixed form.
`interval`	`string`	Yes	Candle interval. One of `"1m"`, `"3m"`, `"5m"`, `"15m"`, `"30m"`, `"1h"`, `"2h"`, `"4h"`, `"8h"`, `"12h"`, `"1d"`, `"3d"`, `"1w"`, `"1M"`.
`startTime`	`int`	Yes	Unix timestamp in milliseconds. Inclusive lower bound for the window.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "candleSnapshot",
    "req": {
      "coin": "BTC",
      "interval": "1h",
      "startTime": 1735689600000,
      "endTime": 1735776000000
    }
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "candleSnapshot",
    req: {
      coin: "BTC",
      interval: "1h",
      startTime: 1735689600000,
      endTime: 1735776000000,
    },
  }),
});

const candles = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "candleSnapshot",
        "req": {
            "coin": "BTC",
            "interval": "1h",
            "startTime": 1735689600000,
            "endTime": 1735776000000,
        },
    },
)

candles = response.json()

Response

An array of candle objects, oldest first.

[
  {
    "t": 1735689600000,
    "T": 1735693199999,
    "s": "BTC",
    "i": "1h",
    "o": "62739.0",
    "c": "62960.0",
    "h": "63118.0",
    "l": "62711.0",
    "v": "921.9829",
    "n": 16396
  }
]

Field descriptions

Note: The price and volume fields (o, c, h, l, v) are returned as decimal strings, preserving upstream precision. Do not parse them as floats.

Field	Type	Description
`t`	`int`	Candle open time, Unix milliseconds.
`T`	`int`	Candle close time, Unix milliseconds.
`s`	`string`	Coin symbol.
`i`	`string`	Candle interval - echoes the request `interval`.
`o`	`string`	Open price.
`c`	`string`	Close price.
`h`	`string`	High price.
`l`	`string`	Low price.
`v`	`string`	Base-asset volume over the candle.
`n`	`int`	Number of trades in the candle.

Last reviewed: 2026-06-16

clearinghouseState | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "clearinghouseState" is used to fetch a single user’s perpetuals account state by wallet address.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "clearinghouseState", "user": "..."}.

For real-time push instead of polling, subscribe to walletTxs with the same wallet address.
The optional dex field returns state on a HIP-3 deployer’s perp DEX.

Returns a single user’s perpetuals account state: every open position, margin summary, account value, and withdrawable balance. User-keyed: pass a wallet address. Cached and kept fresh by a per-user WebSocket subscription to upstream Hyperliquid, so updates are sub-second after any user event.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"clearinghouseState"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`dex`	`string`	No	HIP-3 builder DEX identifier. Empty string (default) returns canonical Hyperliquid perp state. Pass a builder code to query a HIP-3 deployer’s perp DEX.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "clearinghouseState",
    "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    "dex": ""
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "clearinghouseState",
    user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    dex: "",
  }),
});

const state = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "clearinghouseState",
        "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
        "dex": "",
    },
)

state = response.json()

Response

{
  "marginSummary": {
    "accountValue": "12450.83",
    "totalNtlPos": "8500.00",
    "totalRawUsd": "5200.50",
    "totalMarginUsed": "1700.00"
  },
  "crossMarginSummary": {
    "accountValue": "12450.83",
    "totalNtlPos": "8500.00",
    "totalRawUsd": "5200.50",
    "totalMarginUsed": "1700.00"
  },
  "crossMaintenanceMarginUsed": "850.00",
  "withdrawable": "10750.83",
  "assetPositions": [
    {
      "type": "oneWay",
      "position": {
        "coin": "ETH",
        "szi": "2.5",
        "leverage": { "type": "cross", "value": 5 },
        "entryPx": "3400.0",
        "positionValue": "8500.00",
        "unrealizedPnl": "120.50",
        "returnOnEquity": "0.07",
        "liquidationPx": "2800.5",
        "marginUsed": "1700.00",
        "maxLeverage": 50,
        "cumFunding": {
          "allTime": "12.30",
          "sinceOpen": "1.50",
          "sinceChange": "0.50"
        }
      }
    }
  ],
  "time": 1735689600000
}

Field descriptions

Note: All numeric fields below (account value, position size, prices, funding amounts, etc.) are returned as decimal strings, preserving upstream precision. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`marginSummary`	`object`	Top-level account margin and value summary.
`marginSummary.accountValue`	`string`	Total account value in USD.
`marginSummary.totalNtlPos`	`string`	Total notional position size.
`marginSummary.totalRawUsd`	`string`	Raw USDC balance excluding unrealized PnL.
`marginSummary.totalMarginUsed`	`string`	Margin currently committed to open positions.
`crossMarginSummary`	`object`	Cross-margin subset of the margin summary. Same fields.
`crossMaintenanceMarginUsed`	`string`	Maintenance margin currently used for cross positions.
`withdrawable`	`string`	Amount currently withdrawable, in USD.
`assetPositions`	`array`	Open positions, one entry per coin.
`assetPositions.type`	`string`	Position type - `"oneWay"` for the standard mode.
`assetPositions.position`	`object`	__RESPONSE_ROW__coin string Asset symbol. __RESPONSE_ROW__assetPositions.szi string Signed position size (positive = long, negative = short). __RESPONSE_ROW__assetPositions.leverage object Two shapes: - Cross: `{ "type": "cross", "value": int }` - Isolated: `{ "type": "isolated", "value": int, "rawUsd": string }` `rawUsd` is only present for isolated leverage and may be negative. __RESPONSE_ROW__assetPositions.entryPx string Volume-weighted entry price. __RESPONSE_ROW__assetPositions.positionValue string Current notional value. __RESPONSE_ROW__assetPositions.unrealizedPnl string Unrealized PnL in USD. __RESPONSE_ROW__assetPositions.returnOnEquity string Unrealized return on margin used. __RESPONSE_ROW__assetPositions.liquidationPx string \| null Liquidation price. May be literal JSON `null` when no near-term liquidation applies (e.g. cross-margin with deep cushion). __RESPONSE_ROW__assetPositions.marginUsed string Margin committed to this position. __RESPONSE_ROW__assetPositions.maxLeverage int Maximum leverage for this asset. __RESPONSE_ROW__assetPositions.cumFunding object Cumulative funding paid: `allTime`, `sinceOpen`, `sinceChange`.
`time`	`int`	Snapshot timestamp in milliseconds since Unix epoch.

batchClearinghouseState

fetch perpetuals account state for up to 50 wallets in a single request.

batchSpotClearinghouseState

fetch spot account balances for up to 50 wallets in a single request.

spotClearinghouseState

fetch a single user’s spot account balances by wallet address. Last reviewed: 2026-06-13

delegatorHistory | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "delegatorHistory" is used to reconstruct the sequence of HYPE staking events behind the totals shown in delegatorSummary.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "delegatorHistory", "user": "..."}.

For totals (delegated, undelegated, pending withdrawal sums), use delegatorSummary.
For accrued staking and commission rewards, use delegatorRewards.
For real-time push of staking events, subscribe to walletTxs and read HypercoreDelegationEvent entries.

Returns a user’s HYPE staking event history: every delegate, undelegate, staking-account deposit, and unstake withdrawal, ordered by time. Use this to reconstruct the sequence behind the totals shown in delegatorSummary. User-keyed. Each entry carries a delta whose discriminator describes the event variant.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"delegatorHistory"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "delegatorHistory",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "delegatorHistory",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
  }),
});

const events = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "delegatorHistory",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    },
)

events = response.json()

Response

An array of staking event objects.

[
  {
    "time": 1735689600000,
    "hash": "0x6b9c0a4a3d54b0d4d6b1a0c4d8c9e7f2b6e5d3c2a1f0e9d8c7b6a5f4e3d2c1b0a",
    "delta": {
      "delegate": {
        "validator": "0x5ac99df645f3414876c816caa18b2d234024b487",
        "amount": "1000.5",
        "isUndelegate": false
      }
    }
  }
]

Field descriptions

Note: delta.delegate.amount is returned as a decimal string, preserving upstream precision. Do not parse it as a float.

Field	Type	Description
`time`	`int`	Unix timestamp in milliseconds when the event was applied.
`hash`	`string`	L1 transaction hash that produced the event.
`delta`	`object`	Event-specific payload. The example above shows a `delegate` variant; other variants observed in the wild include `cDeposit` (staking-account deposit) and `withdrawal` (unstake withdrawal). The shape changes per variant.
`delta.delegate.validator`	`string`	Validator address the delegation targets.
`delta.delegate.amount`	`string`	HYPE amount delegated or undelegated.
`delta.delegate.isUndelegate`	`boolean`	`true` for an undelegate, `false` for a delegate.

delegatorRewards

fetch a user’s current HYPE staking position.

delegatorSummary

get a one-shot snapshot of a user’s HYPE staking position for dashboards and portfolio overviews.

fundingHistory

fetch a coin’s historical funding rates and premiums over a time window for funding analytics and basis… Last reviewed: 2026-06-13

delegatorRewards | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "delegatorRewards" is used to fetch a user’s current HYPE staking position.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "delegatorSummary", "user": "..."}.

For the sequence of delegation events behind these totals, use delegatorHistory.
For accrued staking and commission rewards, use delegatorRewards.

Returns a single user’s accrued HYPE staking rewards: one entry per accrual, with the timestamp, the source (delegation reward versus validator commission), and the amount. User-keyed. Use this for tax reports, reward attribution dashboards, and validator P&L; use delegatorHistory for the underlying delegate / undelegate events and delegatorSummary for current totals.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"delegatorRewards"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "delegatorRewards",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "delegatorRewards",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
  }),
});

const rewards = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "delegatorRewards",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    },
)

rewards = response.json()

Response

An array of reward entries.

[
  {
    "time": 1735689600000,
    "source": "delegation",
    "totalAmount": "1.5234"
  },
  {
    "time": 1735776000000,
    "source": "commission",
    "totalAmount": "0.8791"
  }
]

Field descriptions

Note: totalAmount is returned as a decimal string, preserving upstream precision. Do not parse it as a float.

Field	Type	Description
`time`	`int`	Unix timestamp in milliseconds when the reward accrued.
`source`	`string`	Reward source. `"delegation"` for rewards earned by delegating to a validator; `"commission"` for commission earned as a validator on others’ delegations.
`totalAmount`	`string`	Reward amount in HYPE.

delegatorHistory

reconstruct the sequence of HYPE staking events behind the totals shown in delegatorSummary.

delegatorSummary

get a one-shot snapshot of a user’s HYPE staking position for dashboards and portfolio overviews. Last reviewed: 2026-06-13

delegatorSummary | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "delegatorSummary" is used to get a one-shot snapshot of a user’s HYPE staking position for dashboards and portfolio overviews.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "delegatorSummary", "user": "..."}.

For the sequence of delegation events behind these totals, use delegatorHistory.
For accrued staking and commission rewards, use delegatorRewards.

Returns a single user’s HYPE staking summary: the amount currently delegated, the amount sitting undelegated in the staking account, the total of any pending withdrawals, and how many such withdrawals are pending. User-keyed. Use this for a one-shot snapshot; for the underlying sequence of delegate / undelegate / deposit / withdrawal events, use delegatorHistory.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"delegatorSummary"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "delegatorSummary",
    "user": "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "delegatorSummary",
    user: "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036",
  }),
});

const summary = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "delegatorSummary",
        "user": "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036",
    },
)

summary = response.json()

Response

{
  "delegated": "1500.50",
  "undelegated": "250.00",
  "totalPendingWithdrawal": "100.00",
  "nPendingWithdrawals": 2
}

Field descriptions

Note: delegated, undelegated, and totalPendingWithdrawal are returned as decimal strings. Do not parse them as floats.

Field	Type	Description
`delegated`	`string`	HYPE currently delegated to validators.
`undelegated`	`string`	HYPE in the staking account but not delegated.
`totalPendingWithdrawal`	`string`	Sum of HYPE in any in-flight unstake withdrawals.
`nPendingWithdrawals`	`int`	Count of in-flight unstake withdrawals.

delegatorHistory

reconstruct the sequence of HYPE staking events behind the totals shown in delegatorSummary.

delegatorRewards

fetch a user’s current HYPE staking position. Last reviewed: 2026-06-13

frontendOpenOrders | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "frontendOpenOrders" is used to fetch a user’s currently open orders enriched with frontend metadata.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "frontendOpenOrders", "user": "..."}.

Use frontendOpenOrders instead of openOrders when you need the trigger metadata and human-readable order type - exactly what the Hyperliquid web UI displays.
For a real-time stream of order placement and cancellation events, subscribe to walletTxs.

Returns a single user’s currently open orders, enriched with the frontend-only metadata the Hyperliquid web UI uses: TP/SL trigger info, whether the order is a position-level TP/SL, reduce-only flag, and the human-readable order type. User-keyed. Updated on every order placement, cancellation, or fill.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"frontendOpenOrders"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`dex`	`string`	No	HIP-3 builder DEX identifier. Empty string returns orders on the canonical Hyperliquid perp DEX.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "frontendOpenOrders",
    "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    "dex": ""
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "frontendOpenOrders",
    user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    dex: "",
  }),
});

const orders = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "frontendOpenOrders",
        "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
        "dex": "",
    },
)

orders = response.json()

Response

An array of open orders. Each order object includes the standard openOrders fields plus the frontend* enrichment fields.

[
  {
    "coin": "ETH",
    "side": "B",
    "limitPx": "3300.0",
    "sz": "0.5",
    "oid": 95012345,
    "timestamp": 1735689600000,
    "triggerCondition": "N/A",
    "isTrigger": false,
    "triggerPx": "0.0",
    "children": [],
    "isPositionTpsl": false,
    "reduceOnly": false,
    "orderType": "Limit",
    "origSz": "0.5",
    "tif": "Gtc",
    "cloid": null
  },
  {
    "coin": "ETH",
    "side": "A",
    "limitPx": "3800.0",
    "sz": "2.5",
    "oid": 95012346,
    "timestamp": 1735689700000,
    "triggerCondition": "Mark price >= 3800.0",
    "isTrigger": true,
    "triggerPx": "3800.0",
    "children": [],
    "isPositionTpsl": true,
    "reduceOnly": true,
    "orderType": "Take Profit Market",
    "origSz": "2.5",
    "tif": null,
    "cloid": null
  }
]

Field descriptions

Field	Type	Description
`coin`	`string`	Asset symbol.
`side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`limitPx`	`string`	Limit price.
`sz`	`string`	Remaining order size.
`oid`	`int`	Numeric order ID.
`timestamp`	`int`	Order placement time in milliseconds since Unix epoch.
`triggerCondition`	`string`	Human-readable trigger condition. `"N/A"` for non-trigger orders.
`isTrigger`	`boolean`	`true` for stop-loss, take-profit, and other conditional orders.
`triggerPx`	`string`	Trigger price for conditional orders. `"0.0"` for limits.
`children`	`array`	Child orders attached to this parent (e.g. bracket orders).
`isPositionTpsl`	`boolean`	`true` if this is a position-level TP/SL (closes the entire position when triggered).
`reduceOnly`	`boolean`	`true` if this order can only reduce, not increase, position size.
`orderType`	`string`	Human-readable order type - `"Limit"`, `"Take Profit Market"`, `"Stop Limit"`, etc.
`origSz`	`string`	Original order size before any partial fills.
`tif`	`string`	Time-in-force - `"Gtc"`, `"Ioc"`, `"Alo"`, or `null` for trigger orders.
`cloid`	`string`	Client order ID (null if not provided at placement).

Last reviewed: 2026-06-13

fundingHistory | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "fundingHistory" is used to fetch a coin’s historical funding rates and premiums over a time window for funding analytics and basis strategies.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "fundingHistory", "coin": "..."}.

Each response contains at most 500 entries per call.
This is market-wide funding history for a coin. For a single wallet’s actual funding payments, use userFunding instead.
For the current funding rate alongside live market context, use metaAndAssetCtxs.

Returns the sequence of applied funding intervals for a single coin within a [startTime, endTime] window. Each entry carries the funding rate that was applied and the mark-vs-oracle premium at that time. Use it for funding-rate charts, basis/carry analytics, and historical funding P&L modeling. This is a global, non-user-keyed type. Page through time by advancing startTime.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"fundingHistory"`.
`coin`	`string`	Yes	The asset symbol, e.g. `"BTC"`. HIP-3 markets use the deployer-prefixed form.
`startTime`	`int`	Yes	Unix timestamp in milliseconds. Inclusive lower bound for the window.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "fundingHistory",
    "coin": "BTC",
    "startTime": 1735689600000,
    "endTime": 1735776000000
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "fundingHistory",
    coin: "BTC",
    startTime: 1735689600000,
    endTime: 1735776000000,
  }),
});

const history = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "fundingHistory",
        "coin": "BTC",
        "startTime": 1735689600000,
        "endTime": 1735776000000,
    },
)

history = response.json()

Response

An array of funding-interval objects, oldest first.

[
  {
    "coin": "BTC",
    "fundingRate": "0.0000054021",
    "premium": "-0.0004567829",
    "time": 1735693200000
  }
]

Field descriptions

Note: fundingRate and premium are returned as decimal strings, preserving upstream precision. Do not parse them as floats.

Field	Type	Description
`coin`	`string`	The asset the funding interval is for - echoes the request `coin`.
`fundingRate`	`string`	The funding rate applied for this interval (decimal string, e.g. `"0.0000125"`).
`premium`	`string`	Mark-vs-oracle premium at the time the funding was computed (decimal string).
`time`	`int`	Unix timestamp in milliseconds when the funding interval was applied.

delegatorHistory

reconstruct the sequence of HYPE staking events behind the totals shown in delegatorSummary.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution.

userNonFundingLedgerUpdates

fetch a user’s USDC and account ledger history within a time window, excluding funding payments, for… Last reviewed: 2026-06-13

l2Book | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "l2Book" is used to fetch an aggregated Level-2 order book snapshot for a single coin - bids and asks as price, size, and order-count levels.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "l2Book", "coin": "..."}.

Returns at most 20 levels per side.
For a continuous push stream instead of polling snapshots, subscribe to the WebSocket API l2Book channel (optional wildcard coin) or the GoldRush-native l2BookDiff for incremental updates.

Returns a point-in-time aggregated order book for one coin: two arrays of price levels (bids first, then asks), each level carrying the price, the total resting size at that price, and the number of orders comprising it. Use it for a one-shot depth snapshot, spread checks, or seeding a book before switching to a diff stream.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"l2Book"`.
`coin`	`string`	Yes	The asset symbol, e.g. `"BTC"`. For HIP-3 markets use the deployer-prefixed form (e.g. `"xyz:GOLD"`); for spot use the pair symbol or `@`.
`nSigFigs`	`int`	No	Number of significant figures to aggregate price levels to (`2`-`5`). Omit or pass `null` for full precision.
`mantissa`	`int`	No	Optional mantissa for price-level bucketing. Only valid when `nSigFigs` is `5`. Omit or pass `null` for the default.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "l2Book",
    "coin": "BTC"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "l2Book",
    coin: "BTC",
  }),
});

const book = await response.json();
const [bids, asks] = book.levels;

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "l2Book", "coin": "BTC"},
)

book = response.json()
bids, asks = book["levels"]

Response

A single JSON object. levels is a two-element array: element 0 is the bid side (descending price), element 1 is the ask side (ascending price). Each level is a {px, sz, n} object.

{
  "coin": "BTC",
  "time": 1780940795265,
  "levels": [
    [
      { "px": "63405.0", "sz": "4.43382", "n": 36 },
      { "px": "63404.0", "sz": "3.38588", "n": 44 }
    ],
    [
      { "px": "63406.0", "sz": "0.00347", "n": 3 },
      { "px": "63407.0", "sz": "0.00017", "n": 1 }
    ]
  ]
}

Field descriptions

Note: px and sz are returned as decimal strings, preserving upstream precision. Do not parse them as floats.

Field	Type	Description
`coin`	`string`	The asset the book is for - echoes the request `coin`.
`time`	`int`	Snapshot timestamp in milliseconds since Unix epoch.
`levels`	`array>`	Two-element array: `levels[0]` are bids (sorted highest price first), `levels[1]` are asks (sorted lowest price first). Each side defaults to up to 20 aggregated levels.
`levels.px`	`string`	Price of the level.
`levels.sz`	`string`	Total resting size at this price.
`levels.n`	`int`	Number of individual orders aggregated into this level.

Last reviewed: 2026-06-16

metaAndAssetCtxs | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "metaAndAssetCtxs" is used to fetch the full Hyperliquid perpetuals market universe with live per-asset trading context.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "metaAndAssetCtxs"}.

For real-time mark-price updates, use the Streaming API OHLCV streams instead of polling.

Returns a tuple [meta, assetCtxs[]] covering the entire Hyperliquid perpetuals universe - every coin’s metadata plus a live snapshot of mark price, funding rate, open interest, and 24-hour volume. This is a global, non-user-keyed type. A single cache entry is shared across all callers and is refreshed continuously from upstream Hyperliquid.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"metaAndAssetCtxs"`.
`dex`	`string`	No	HIP-3 builder DEX identifier. Empty string (default) returns the canonical Hyperliquid perp universe. Pass a builder code (e.g. `"xyz"`) to query a HIP-3 deployer’s universe.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "metaAndAssetCtxs",
    "dex": ""
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "metaAndAssetCtxs",
    dex: "",
  }),
});

const [meta, assetCtxs] = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "metaAndAssetCtxs", "dex": ""},
)

meta, asset_ctxs = response.json()

Response

A two-element JSON array. Element 0 is the universe metadata; element 1 is an array of per-asset contexts indexed identically to the universe array.

[
  {
    "universe": [
      { "name": "BTC", "szDecimals": 5, "maxLeverage": 50 },
      { "name": "ETH", "szDecimals": 4, "maxLeverage": 50 },
      { "name": "SOL", "szDecimals": 2, "maxLeverage": 20 }
    ]
  },
  [
    {
      "funding": "0.0000125",
      "openInterest": "12345.67",
      "prevDayPx": "67500.0",
      "dayNtlVlm": "894500000.0",
      "premium": "0.00001",
      "oraclePx": "68210.5",
      "markPx": "68215.0",
      "midPx": "68214.0",
      "impactPxs": ["68210.0", "68220.0"],
      "dayBaseVlm": "13130.45"
    },
    { "funding": "0.0000050", "openInterest": "9876.54", "...": "..." },
    { "funding": "0.0000200", "openInterest": "543210.98", "...": "..." }
  ]
]

Element 0: `meta`

Field	Type	Description
`universe`	`array`	Array of perp asset metadata, indexed identically to element 1’s `assetCtxs`.
`universe.name`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"`. For HIP-3 markets, includes the deployer prefix.
`universe.szDecimals`	`int`	Number of decimals for size precision.
`universe.maxLeverage`	`int`	Maximum leverage for this asset.
`universe.onlyIsolated`	`boolean`	If true, the asset only supports isolated margin.

Element 1: `assetCtxs[]`

Array of per-asset live context, indexed identically to universe.

Field	Type	Description
`funding`	`string`	Current funding rate (decimal string).
`openInterest`	`string`	Open interest in base units.
`prevDayPx`	`string`	Mark price 24 hours ago.
`dayNtlVlm`	`string`	24-hour notional volume in USD.
`premium`	`string`	Mark vs oracle premium.
`oraclePx`	`string`	Current oracle price.
`markPx`	`string`	Current mark price.
`midPx`	`string`	Current orderbook mid price.
`impactPxs`	`array`	Bid/ask impact prices `[bidImpact, askImpact]`.
`dayBaseVlm`	`string`	24-hour volume in base units.

spotMetaAndAssetCtxs

fetch the spot universe metadata, token configuration, and live market data in a single call.

meta

fetch the perpetuals universe metadata without live market context.

outcomeMeta

enumerate all active HIP-4 binary outcome markets on HyperCore.

spotMeta

fetch the spot universe metadata and full token configuration without live market context. Last reviewed: 2026-06-13

meta | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "meta" is used to fetch the perpetuals universe metadata without live market context.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "meta"}.

Use metaAndAssetCtxs when you also need live per-asset mark price, funding, open interest, and day volume.
The optional dex field takes a perp DEX name. It defaults to the empty string which represents the first perp DEX.
For the spot equivalent, use spotMeta.

Returns the static metadata for the entire Hyperliquid perpetuals universe: every coin’s symbol, size-decimal precision, maximum leverage, and the margin-tier table it references. Unlike metaAndAssetCtxs, this payload carries no live market data, so it is cheap to cache and changes only when listings or margin parameters change.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"meta"`.
`dex`	`string`	No	HIP-3 builder DEX identifier. Empty string (default) returns the canonical Hyperliquid perp universe. Pass a builder code (e.g. `"xyz"`) to query a HIP-3 deployer’s universe.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "meta",
    "dex": ""
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "meta",
    dex: "",
  }),
});

const meta = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "meta", "dex": ""},
)

meta = response.json()

Response

A single JSON object describing the perp universe, the margin-tier tables it references, and the collateral token.

{
  "universe": [
    { "name": "BTC", "szDecimals": 5, "maxLeverage": 40, "marginTableId": 56 },
    { "name": "ETH", "szDecimals": 4, "maxLeverage": 25, "marginTableId": 55 },
    { "name": "MATIC", "szDecimals": 1, "maxLeverage": 20, "marginTableId": 20, "isDelisted": true }
  ],
  "marginTables": [
    [
      50,
      {
        "description": "",
        "marginTiers": [
          { "lowerBound": "0.0", "maxLeverage": 50 }
        ]
      }
    ]
  ],
  "collateralToken": 0
}

Field descriptions

Field	Type	Description
`universe`	`array`	Array of perp asset metadata.
`universe.name`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"`. For HIP-3 markets, includes the deployer prefix.
`universe.szDecimals`	`int`	Number of decimals for size precision.
`universe.maxLeverage`	`int`	Maximum leverage for this asset.
`universe.marginTableId`	`int`	Identifier of the margin-tier table in `marginTables` that governs this asset.
`universe.onlyIsolated`	`boolean`	If true, the asset only supports isolated margin. Omitted when false.
`universe.isDelisted`	`boolean`	If true, the asset has been delisted and is no longer tradeable. Omitted when false.
`marginTables`	`array`	Margin-tier tables, each a `[id, table]` tuple. `id` matches a `universe[].marginTableId`; `table` holds a `description` and a `marginTiers` array of `{lowerBound, maxLeverage}` steps describing how max leverage decreases as position notional grows.
`collateralToken`	`int`	Token index of the collateral asset backing the perp universe (USDC is `0`).

metaAndAssetCtxs

fetch the full Hyperliquid perpetuals market universe with live per-asset trading context.

outcomeMeta

enumerate all active HIP-4 binary outcome markets on HyperCore.

spotMeta

fetch the spot universe metadata and full token configuration without live market context.

spotMetaAndAssetCtxs

fetch the spot universe metadata, token configuration, and live market data in a single call. Last reviewed: 2026-06-13

outcomeMeta | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "outcomeMeta" is used to enumerate all active HIP-4 binary outcome markets on HyperCore.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "outcomeMeta"}.

For real-time price updates on a discovered outcome, subscribe to ohlcvCandlesForPair using the per-side encoding. See the HIP-4 markets recipe for end-to-end discovery and streaming patterns.
HIP-4 launched on Hyperliquid mainnet on May 2, 2026. Read the canonical spec: HIP-4: Outcome markets.

Returns the live HIP-4 outcome universe: every active binary outcome market on HyperCore with its integer outcome ID, human-readable name, structured description, and sideSpecs (Yes / No). This is a global, non-user-keyed type. A single cache entry is shared across all callers and is refreshed continuously from upstream Hyperliquid. outcomeMeta is HIP-4’s dedicated metadata type - separate from metaAndAssetCtxs, which covers perps and spot. Use it to discover live outcome IDs and compute per-side market encodings (encoding = 10 * outcome + side) before subscribing to OHLCV or fills.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"outcomeMeta"`.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "outcomeMeta"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "outcomeMeta",
  }),
});

const { outcomes } = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "outcomeMeta"},
)

outcomes = response.json()["outcomes"]

Response

{
  "outcomes": [
    {
      "outcome": 123,
      "name": "Recurring",
      "description": "class:priceBinary|underlying:HYPE|expiry:20260310-1100|targetPrice:34.5|period:3m",
      "sideSpecs": [
        { "name": "Yes" },
        { "name": "No" }
      ]
    }
  ]
}

Field descriptions

Field	Type	Description
`outcomes`	`array`	Array of active outcome markets.
`outcomes.outcome`	`int`	Integer outcome ID. Combine with a side index to compute the tradeable market encoding: `encoding = 10 * outcome + side`. An outcome with `Yes` (side 0) and `No` (side 1) yields two encodings (e.g. `1230` and `1231`).
`outcomes.name`	`string`	Human-readable label for the market - for example, `"Recurring"` for repeating daily/weekly markets.
`outcomes.description`	`string`	Pipe-delimited spec describing the market. Parse it once to extract the full definition: \| Field \| Example \| Meaning \| \|---\|---\|---\| \| `class` \| `priceBinary` \| Market class (binary outcome on a price threshold). \| \| `underlying` \| `HYPE` \| Asset the outcome resolves against. \| \| `expiry` \| `20260310-1100` \| Resolution timestamp, `YYYYMMDD-HHMM` UTC. \| \| `targetPrice` \| `34.5` \| Threshold the underlying is compared against at expiry. \| \| `period` \| `3m` \| Recurrence cadence for repeating markets. \|
`outcomes.sideSpecs`	`array`	Tradeable sides of the outcome, ordered by side index. For binary outcomes, index 0 is `Yes` and index 1 is `No`. __RESPONSE_ROW__name string Side label - typically `"Yes"` or `"No"` for binary outcomes.

meta

fetch the perpetuals universe metadata without live market context.

metaAndAssetCtxs

fetch the full Hyperliquid perpetuals market universe with live per-asset trading context.

spotMeta

fetch the spot universe metadata and full token configuration without live market context.

spotMetaAndAssetCtxs

fetch the spot universe metadata, token configuration, and live market data in a single call. Last reviewed: 2026-06-13

spotClearinghouseState | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "spotClearinghouseState" is used to fetch a single user’s spot account balances by wallet address.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "spotClearinghouseState", "user": "..."}.

USDC balance is returned as token: 0.
For real-time push of spot transfers, subscribe to walletTxs and read LedgerSpotTransfer events.

Returns a single user’s spot account state - token-by-token balances and the total USD value. User-keyed. Cached and kept fresh by a per-user WebSocket subscription, so updates are sub-second after any user event.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"spotClearinghouseState"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`dex`	`string`	No	Reserved for future HIP-3 spot DEX support. Pass empty string.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "spotClearinghouseState",
    "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    "dex": ""
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "spotClearinghouseState",
    user: "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
    dex: "",
  }),
});

const state = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "spotClearinghouseState",
        "user": "0xecb63caa47c7c4e77f60f1ce858cf28dc2b82b00",
        "dex": "",
    },
)

state = response.json()

Response

{
  "balances": [
    {
      "coin": "USDC",
      "token": 0,
      "hold": "0.0",
      "total": "5000.00",
      "entryNtl": "5000.00"
    },
    {
      "coin": "HYPE",
      "token": 150,
      "hold": "0.0",
      "total": "320.45",
      "entryNtl": "1530.00"
    },
    {
      "coin": "PURR",
      "token": 1,
      "hold": "0.0",
      "total": "12500.0",
      "entryNtl": "375.00"
    }
  ],
  "tokenToAvailableAfterMaintenance": [[0, "5000.00"]]
}

Field descriptions

Note: All numeric balance fields (total, hold, entryNtl) are returned as decimal strings, preserving upstream precision. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`balances`	`array`	One entry per token the wallet has interacted with on Hyperliquid spot. May be empty (`[]`) for wallets with no spot history.
`balances.coin`	`string`	Token ticker symbol (e.g. `"USDC"`, `"PURR"`, `"HYPE"`).
`balances.token`	`int`	Numeric token index assigned by Hyperliquid. The pair `(coin, token)` together identifies the asset.
`balances.hold`	`string`	Portion of `total` currently locked in open spot orders. Withdrawable balance is `total - hold`.
`balances.total`	`string`	Total balance (held + free).
`balances.entryNtl`	`string`	Entry notional value at acquisition, in USD.
`tokenToAvailableAfterMaintenance`	`array`	Optional. Present only when at least one token has a non-zero margin-deduction-aware balance. Each tuple is `[tokenId, availableAmountString]` where `tokenId` references `balances[].token`. Wallets without this field can ignore it; absence is normal for empty or inactive wallets.

batchSpotClearinghouseState

fetch spot account balances for up to 50 wallets in a single request.

batchClearinghouseState

fetch perpetuals account state for up to 50 wallets in a single request.

clearinghouseState

fetch a single user’s perpetuals account state by wallet address.

spotMeta

fetch the spot universe metadata and full token configuration without live market context. Last reviewed: 2026-06-13

spotMetaAndAssetCtxs | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "spotMetaAndAssetCtxs" is used to fetch the spot universe metadata, token configuration, and live market data in a single call.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "spotMetaAndAssetCtxs"}.

For perp universe + live contexts, use metaAndAssetCtxs instead.
For real-time mark-price updates on a discovered spot pair, use the Streaming API OHLCV pair stream.

Returns a tuple [spotMeta, assetCtxs[]] covering the entire Hyperliquid spot universe - every pair’s universe entry, every token’s metadata, and a live snapshot of mark price, mid price, prior-day price, and 24-hour notional volume per pair. This is the spot counterpart of metaAndAssetCtxs. Global, non-user-keyed; a single cache entry is shared across all callers and refreshed continuously from upstream Hyperliquid.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"spotMetaAndAssetCtxs"`.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "spotMetaAndAssetCtxs"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "spotMetaAndAssetCtxs",
  }),
});

const [spotMeta, assetCtxs] = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "spotMetaAndAssetCtxs"},
)

spot_meta, asset_ctxs = response.json()

Response

A two-element JSON array. Element 0 is the spot universe and token metadata; element 1 is an array of per-pair live contexts indexed identically to element 0’s universe.

[
  {
    "universe": [
      {
        "name": "PURR/USDC",
        "tokens": [1, 0],
        "index": 0,
        "isCanonical": true
      }
    ],
    "tokens": [
      {
        "name": "USDC",
        "szDecimals": 8,
        "weiDecimals": 8,
        "index": 0,
        "tokenId": "0x6d1e7cde53ba9467b783cb7c530ce054",
        "isCanonical": true,
        "evmContract": null,
        "fullName": null
      },
      {
        "name": "PURR",
        "szDecimals": 0,
        "weiDecimals": 5,
        "index": 1,
        "tokenId": "0xc1fb593aeffbeb02f85e0308e9956a90",
        "isCanonical": true,
        "evmContract": null,
        "fullName": null
      }
    ]
  },
  [
    {
      "coin": "PURR/USDC",
      "markPx": "0.5250",
      "midPx": "0.5245",
      "prevDayPx": "0.4800",
      "dayNtlVlm": "1250000.0",
      "dayBaseVlm": "2380952.38",
      "circulatingSupply": "1000000000.0"
    }
  ]
]

Element 0: `spotMeta`

Field	Type	Description
`universe`	`array`	Array of spot pairs, indexed identically to element 1’s `assetCtxs`.
`universe.name`	`string`	Pair label - e.g. `"PURR/USDC"`.
`universe.tokens`	`array`	Two-element array of token indices `[base, quote]` referencing entries in `tokens[].index`.
`universe.index`	`int`	Numeric pair index. The spot encoding for trading subscriptions is `10000 + index`.
`universe.isCanonical`	`boolean`	`true` for pairs in the canonical Hyperliquid spot universe.
`tokens`	`array`	Token configuration referenced by `universe[].tokens`.
`tokens.name`	`string`	Token symbol - e.g. `"USDC"`, `"PURR"`.
`tokens.szDecimals`	`int`	Number of decimals used for size precision.
`tokens.weiDecimals`	`int`	Number of decimals used for the on-chain wei representation.
`tokens.index`	`int`	Token index. `(coin, index)` together identifies the asset.
`tokens.tokenId`	`string`	Hyperliquid token identifier (hex).
`tokens.isCanonical`	`boolean`	`true` for tokens deployed in the canonical Hyperliquid spot universe.
`tokens.evmContract`	`object	null`	EVM contract address if the token has an HyperEVM mapping; `null` otherwise.
`tokens.fullName`	`string	null`	Optional full token name.

Element 1: `assetCtxs[]`

Array of per-pair live context, indexed identically to universe.

Note: All numeric fields below are returned as decimal strings. Do not parse them as floats.

Field	Type	Description
`coin`	`string`	Pair symbol - matches `universe[].name`.
`markPx`	`string`	Current mark price.
`midPx`	`string`	Current orderbook mid price.
`prevDayPx`	`string`	Mark price 24 hours ago.
`dayNtlVlm`	`string`	24-hour notional volume in USDC.
`dayBaseVlm`	`string`	24-hour volume in base units.
`circulatingSupply`	`string`	Circulating supply of the base token.

metaAndAssetCtxs

fetch the full Hyperliquid perpetuals market universe with live per-asset trading context.

spotMeta

fetch the spot universe metadata and full token configuration without live market context.

batchSpotClearinghouseState

fetch spot account balances for up to 50 wallets in a single request.

meta

fetch the perpetuals universe metadata without live market context. Last reviewed: 2026-06-13

spotMeta | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "spotMeta" is used to fetch the spot universe metadata and full token configuration without live market context.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "spotMeta"}.

Use spotMetaAndAssetCtxs when you also need live per-pair mark price, mid, and day volume.
For the perpetuals equivalent, use meta.

Returns the static metadata for the entire Hyperliquid spot market: the list of trading pairs (universe) and the full token registry (tokens) with each token’s decimals, on-chain identifier, and linked HyperEVM contract. Carries no live market data, so it is cheap to cache and changes only when new tokens or pairs are listed.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"spotMeta"`.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "spotMeta"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "spotMeta",
  }),
});

const spotMeta = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={"type": "spotMeta"},
)

spot_meta = response.json()

Response

A single JSON object with two arrays: tokens (the token registry) and universe (the tradeable pairs that reference those tokens by index).

{
  "tokens": [
    {
      "name": "USDC",
      "szDecimals": 8,
      "weiDecimals": 8,
      "index": 0,
      "tokenId": "0x6d1e7cde53ba9467b783cb7c530ce054",
      "isCanonical": true,
      "evmContract": {
        "address": "0x6b9e773128f453f5c2c60935ee2de2cbc5390a24",
        "evm_extra_wei_decimals": -2
      },
      "fullName": null,
      "deployerTradingFeeShare": "0.0"
    },
    {
      "name": "PURR",
      "szDecimals": 0,
      "weiDecimals": 5,
      "index": 1,
      "tokenId": "0xc1fb593aeffbeb02f85e0308e9956a90",
      "isCanonical": true,
      "evmContract": null,
      "fullName": null,
      "deployerTradingFeeShare": "0.0"
    }
  ],
  "universe": [
    { "tokens": [1, 0], "name": "PURR/USDC", "index": 0, "isCanonical": true }
  ]
}

`tokens[]`

Field	Type	Description
`name`	`string`	Token symbol - e.g. `"USDC"`, `"PURR"`.
`szDecimals`	`int`	Number of decimals used for order size precision.
`weiDecimals`	`int`	Number of decimals in the token’s native wei representation.
`index`	`int`	Token index. `universe[].tokens` references tokens by this value.
`tokenId`	`string`	Hyperliquid on-chain token identifier.
`isCanonical`	`boolean`	Whether the token is a canonical (core) Hyperliquid token.
`evmContract`	`object	null`	Linked HyperEVM contract, or `null` if the token is not bridged. Carries `address` and `evm_extra_wei_decimals` (the wei-decimal offset between the spot token and its EVM representation).
`fullName`	`string	null`	Human-readable token name, or `null` when not set.
`deployerTradingFeeShare`	`string`	Share of trading fees routed to the token deployer (decimal string).

`universe[]`

Field	Type	Description
`name`	`string`	Pair symbol - e.g. `"PURR/USDC"`. Non-canonical pairs use the `@` form (e.g. `"@1"`).
`tokens`	`array`	Two-element `[base, quote]` array of token indices into `tokens`.
`index`	`int`	Pair index. Used as the spot asset identifier in other endpoints and streams.
`isCanonical`	`boolean`	Whether the pair is a canonical Hyperliquid market.

spotMetaAndAssetCtxs

fetch the spot universe metadata, token configuration, and live market data in a single call.

batchSpotClearinghouseState

fetch spot account balances for up to 50 wallets in a single request.

meta

fetch the perpetuals universe metadata without live market context.

metaAndAssetCtxs

fetch the full Hyperliquid perpetuals market universe with live per-asset trading context. Last reviewed: 2026-06-13

subAccounts | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "subAccounts" is used to fetch a master wallet’s sub-accounts along with their full perp and spot state in a single call.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "subAccounts", "user": "..."}.

For per-sub-account real-time updates, subscribe to walletTxs on each subAccountUser returned here.
For multi-wallet polling without traversing master/sub-account hierarchy, see batchClearinghouseState and batchSpotClearinghouseState.

Returns the sub-accounts owned by a master wallet, with each sub-account’s perp clearinghouseState and spot spotClearinghouseState inlined per slot - so a single call returns the full balance picture across the master plus its sub-accounts. User-keyed. The result is null for wallets that aren’t master accounts.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"subAccounts"`.
`user`	`string`	Yes	The master wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "subAccounts",
    "user": "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "subAccounts",
    user: "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036",
  }),
});

const subAccounts = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "subAccounts",
        "user": "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036",
    },
)

sub_accounts = response.json()

Response

An array of sub-account objects, or null if the queried wallet is not a master account.

[
  {
    "name": "trading-bot-1",
    "subAccountUser": "0x2b804617c6f63c040377e95bb276811747006f4b",
    "master": "0x2ba553d9f990a3b66b03b2dc0d030dfc1c061036",
    "clearinghouseState": {
      "marginSummary": {
        "accountValue": "5000.00",
        "totalNtlPos": "0.0",
        "totalRawUsd": "5000.00",
        "totalMarginUsed": "0.0"
      },
      "crossMarginSummary": {
        "accountValue": "5000.00",
        "totalNtlPos": "0.0",
        "totalRawUsd": "5000.00",
        "totalMarginUsed": "0.0"
      },
      "crossMaintenanceMarginUsed": "0.0",
      "withdrawable": "5000.00",
      "assetPositions": [],
      "time": 1735689600000
    },
    "spotState": {
      "balances": [
        { "coin": "USDC", "token": 0, "hold": "0.0", "total": "1000.00", "entryNtl": "1000.00" }
      ]
    }
  }
]

Field descriptions

Field	Type	Description
`name`	`string`	Optional human-readable label assigned to the sub-account.
`subAccountUser`	`string`	The sub-account’s wallet address (0x-prefixed hex).
`master`	`string`	The master wallet address that owns this sub-account.
`clearinghouseState`	`object`	Perp account state for this sub-account. Identical shape to the single-wallet `clearinghouseState` response - margin summaries, asset positions, withdrawable balance, snapshot timestamp.
`spotState`	`object`	Spot account state for this sub-account. Identical shape to the single-wallet `spotClearinghouseState` response - per-token balances and the optional `tokenToAvailableAfterMaintenance` array.

Last reviewed: 2026-06-13

userFillsByTime | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userFillsByTime" is used to fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userFillsByTime", "user": "...", "startTime": ...}.

Each response contains at most 2,000 fills; widen the window in chunks or page by advancing startTime if you need more.
GoldRush serves this type from a dedicated HyperCore historical store, so windows older than upstream Hyperliquid’s 10,000-fill retention are still fulfilled.
For real-time push instead of windowed polling, subscribe to walletTxs and read HypercoreFillTransaction events.
Use userFills (no Time suffix) when you only need the most recent N fills without specifying a window.

Returns a single user’s fills bounded by a [startTime, endTime) window in milliseconds. Use this when you want fills since a specific moment - daily P&L recaps, post-deploy backfills, or rebuilding a tax ledger - rather than the most recent N fills. User-keyed. The upstream Hyperliquid API caps each response at 2,000 fills; page by advancing startTime. NOT LIMITED TO THE 10,000 MOST RECENT FILLS. GoldRush serves this type from a dedicated HyperCore historical store so windows extending past the upstream retention limit are fulfilled from GoldRush data rather than truncated.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userFillsByTime"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`startTime`	`int`	Yes	Unix timestamp in milliseconds. Inclusive lower bound.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.
`aggregateByTime`	`boolean`	No	When `true`, partial fills sharing the same timestamp are consolidated into one row. Default `false`.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userFillsByTime",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    "startTime": 1735689600000
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userFillsByTime",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    startTime: 1735689600000,
  }),
});

const fills = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userFillsByTime",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
        "startTime": 1735689600000,
    },
)

fills = response.json()

Response

An array of fill objects ordered by time.

[
  {
    "coin": "BTC",
    "px": "43250.5",
    "sz": "0.1",
    "side": "B",
    "time": 1735689600000,
    "startPosition": "0",
    "dir": "Open Long",
    "closedPnl": "0",
    "hash": "0x6b9c0a4a3d54b0d4d6b1a0c4d8c9e7f2b6e5d3c2a1f0e9d8c7b6a5f4e3d2c1b0a",
    "oid": 95012345,
    "tid": 678900012345,
    "crossed": true,
    "fee": "2.16",
    "feeToken": "USDC"
  }
]

Field descriptions

Note: All numeric fields (px, sz, startPosition, closedPnl, fee, builderFee) are returned as decimal strings, preserving upstream precision. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`coin`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`).
`px`	`string`	Fill execution price.
`sz`	`string`	Fill size.
`side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`time`	`int`	Unix timestamp in milliseconds when the fill executed.
`startPosition`	`string`	Signed position size on the same coin immediately before this fill.
`dir`	`string`	Human-readable direction label - e.g. `"Open Long"`, `"Close Short"`, `"Buy"`, `"Sell"`.
`closedPnl`	`string`	Realized PnL in USDC attributable to this fill (zero when the fill opens or extends a position).
`hash`	`string`	L1 transaction hash that included this fill.
`oid`	`int`	Parent order ID.
`tid`	`int`	Unique trade ID.
`crossed`	`boolean`	`true` when the fill came from the taker side of the order, `false` when it was the maker side.
`fee`	`string`	Trading fee paid for this fill, denominated in `feeToken`.
`feeToken`	`string`	Symbol the fee was paid in - typically `"USDC"`.
`builderFee`	`string`	Optional. Builder fee paid for this fill if the order routed through a builder code.
`twapId`	`int	null`	Optional TWAP order ID if this fill is a slice of a TWAP order.
`cloid`	`string	null`	Optional client order ID if one was set at order placement.

userFills

fetch a user’s most recent trade fills without specifying a time window.

userTwapSliceFills

fetch a user’s most recent TWAP slice fills for execution-quality analytics on algorithmic orders.

builderFills

fetch a builder’s most recent attributed trade fills for revenue attribution and order-flow analytics.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution. Last reviewed: 2026-06-16

userFills | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userFills" is used to fetch a user’s most recent trade fills without specifying a time window.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userFills", "user": "..."}.

Each response contains at most 2,000 fills.
For real-time push instead of windowed polling, subscribe to walletTxs and read HypercoreFillTransaction events.

Returns the most recent fills for a user, up to 2,000. Use this when you need the latest trade activity without specifying a time window. User-keyed. The upstream Hyperliquid API caps each response at 2,000 fills per wallet.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userFills"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`aggregateByTime`	`boolean`	No	When `true`, partial fills sharing the same timestamp are consolidated into one row. Default `false`.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userFills",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userFills",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
  }),
});

const fills = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userFills",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    },
)

fills = response.json()

Response

An array of fill objects ordered most-recent-first.

[
  {
    "coin": "BTC",
    "px": "43250.5",
    "sz": "0.1",
    "side": "B",
    "time": 1735689600000,
    "startPosition": "0",
    "dir": "Open Long",
    "closedPnl": "0",
    "hash": "0x6b9c0a4a3d54b0d4d6b1a0c4d8c9e7f2b6e5d3c2a1f0e9d8c7b6a5f4e3d2c1b0a",
    "oid": 95012345,
    "tid": 678900012345,
    "crossed": true,
    "fee": "2.16",
    "feeToken": "USDC"
  }
]

Field descriptions

Note: All numeric fields (px, sz, startPosition, closedPnl, fee, builderFee) are returned as decimal strings, preserving upstream precision. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`coin`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`).
`px`	`string`	Fill execution price.
`sz`	`string`	Fill size.
`side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`time`	`int`	Unix timestamp in milliseconds when the fill executed.
`startPosition`	`string`	Signed position size on the same coin immediately before this fill.
`dir`	`string`	Human-readable direction label - e.g. `"Open Long"`, `"Close Short"`, `"Buy"`, `"Sell"`.
`closedPnl`	`string`	Realized PnL in USDC attributable to this fill (zero when the fill opens or extends a position).
`hash`	`string`	L1 transaction hash that included this fill.
`oid`	`int`	Parent order ID.
`tid`	`int`	Unique trade ID.
`crossed`	`boolean`	`true` when the fill came from the taker side of the order, `false` when it was the maker side.
`fee`	`string`	Trading fee paid for this fill, denominated in `feeToken`.
`feeToken`	`string`	Symbol the fee was paid in - typically `"USDC"`.
`builderFee`	`string`	Optional. Builder fee paid for this fill if the order routed through a builder code.
`twapId`	`int	null`	Optional TWAP order ID if this fill is a slice of a TWAP order.
`cloid`	`string	null`	Optional client order ID if one was set at order placement.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

userTwapSliceFills

fetch a user’s most recent TWAP slice fills for execution-quality analytics on algorithmic orders.

builderFills

fetch a builder’s most recent attributed trade fills for revenue attribution and order-flow analytics.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution. Last reviewed: 2026-06-13

userFunding | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userFunding" is used to fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userFunding", "user": "..."}.

For real-time push, subscribe to walletTxs and read HypercoreFundingEvent entries.
Use userNonFundingLedgerUpdates for deposits, withdrawals, transfers, vault flows, liquidations, and other balance-moving events.

Returns a single user’s funding payment history within a [startTime, endTime) window. Each entry is one funding application: a coin, the rate that was applied, the position size at the time, and the resulting USDC delta (negative = paid, positive = received). User-keyed. Use this for funding-only P&L attribution; use userNonFundingLedgerUpdates for everything else.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userFunding"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`startTime`	`int`	No	Unix timestamp in milliseconds. Inclusive lower bound for the window.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userFunding",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    "startTime": 1735689600000,
    "endTime": 1735776000000
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userFunding",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    startTime: 1735689600000,
    endTime: 1735776000000,
  }),
});

const events = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userFunding",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
        "startTime": 1735689600000,
        "endTime": 1735776000000,
    },
)

events = response.json()

Response

An array of funding event objects, one per applied funding interval and coin.

[
  {
    "time": 1735689600000,
    "hash": "0x6b9c0a4a3d54b0d4d6b1a0c4d8c9e7f2b6e5d3c2a1f0e9d8c7b6a5f4e3d2c1b0a",
    "delta": {
      "type": "funding",
      "coin": "BTC",
      "usdc": "-50.25",
      "szi": "1.5",
      "fundingRate": "0.0001",
      "nSamples": null
    }
  }
]

Field descriptions

Note: All numeric delta fields are returned as decimal strings. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`time`	`int`	Unix timestamp in milliseconds when the funding payment was applied.
`hash`	`string`	L1 transaction hash that included the funding application.
`delta`	`object`	Funding-event payload.
`delta.type`	`string`	Always `"funding"` for entries returned by this endpoint.
`delta.coin`	`string`	Asset symbol the funding rate applied to.
`delta.usdc`	`string`	USDC delta credited to or debited from the account. Negative values are paid, positive values are received.
`delta.szi`	`string`	Signed position size at the time of application (positive = long, negative = short).
`delta.fundingRate`	`string`	The funding rate applied (decimal string, e.g. `"0.0001"` for 1 bp).
`delta.nSamples`	`int	null`	Optional - number of samples used by the upstream funding calculation. May be `null`.

userNonFundingLedgerUpdates

fetch a user’s USDC and account ledger history within a time window, excluding funding payments, for…

fundingHistory

fetch a coin’s historical funding rates and premiums over a time window for funding analytics and basis…

userFills

fetch a user’s most recent trade fills without specifying a time window.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction. Last reviewed: 2026-06-13

userNonFundingLedgerUpdates | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userNonFundingLedgerUpdates" is used to fetch a user’s USDC and account ledger history within a time window, excluding funding payments, for rendering fee accruals separately from balance-moving events.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userNonFundingLedgerUpdates", "user": "..."}.

Funding payments are not included here - use userFunding.
For real-time push of the same events, subscribe to walletTxs; the delta.type discriminator on the polled response maps 1:1 to the streamed LedgerDelta interface in the Streaming API.

Returns a single user’s USDC and account ledger history within a [startTime, endTime) window, excluding funding payments. Funding events are intentionally separated into their own type, userFunding, so applications can render fee accruals separately from balance-moving events. User-keyed. Each entry carries a delta whose type discriminates the event variant - deposits, withdrawals, internal transfers, sub-account transfers, vault flows, liquidations, rewards claims, and similar.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userNonFundingLedgerUpdates"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).
`startTime`	`int`	No	Unix timestamp in milliseconds. Inclusive lower bound for the window.
`endTime`	`int`	No	Unix timestamp in milliseconds. Inclusive upper bound. Defaults to current server time when omitted.

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userNonFundingLedgerUpdates",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    "startTime": 1735689600000
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userNonFundingLedgerUpdates",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    startTime: 1735689600000,
  }),
});

const events = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userNonFundingLedgerUpdates",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
        "startTime": 1735689600000,
    },
)

events = response.json()

Response

An array of ledger event objects. Each entry has time, hash, and a delta discriminated by delta.type.

[
  {
    "time": 1735689600000,
    "hash": "0x6b9c0a4a3d54b0d4d6b1a0c4d8c9e7f2b6e5d3c2a1f0e9d8c7b6a5f4e3d2c1b0a",
    "delta": {
      "type": "vaultWithdraw",
      "vault": "0x1962905b0a2d0ce8907a92ed5f7a17fef3e1b53e",
      "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
      "requestedUsd": "1000.50",
      "commission": "10.00",
      "closingCost": "5.25",
      "basis": "950.00",
      "netWithdrawnUsd": "985.25"
    }
  }
]

Field descriptions

Note: All numeric delta fields are returned as decimal strings. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`time`	`int`	Unix timestamp in milliseconds when the event was applied.
`hash`	`string`	L1 transaction hash that produced the event.
`delta`	`object`	Event-specific payload. The shape depends on `delta.type`. The example above shows a `vaultWithdraw`; common discriminators include `deposit`, `withdraw`, `accountClassTransfer`, `internalTransfer`, `subAccountTransfer`, `spotTransfer`, `vaultDeposit`, `vaultWithdraw`, `vaultDistribution`, `vaultLeaderCommission`, `liquidation`, `rewardsClaim`, and others. See the Hyperliquid `nonFundingLedgerUpdates` reference for the full discriminator table.
`delta.type`	`string`	Discriminator. Always present on every variant.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution.

fundingHistory

fetch a coin’s historical funding rates and premiums over a time window for funding analytics and basis…

userFills

fetch a user’s most recent trade fills without specifying a time window.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction. Last reviewed: 2026-06-13

userTwapSliceFills | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userTwapSliceFills" is used to fetch a user’s most recent TWAP slice fills for execution-quality analytics on algorithmic orders.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userTwapSliceFills", "user": "..."}.

Each response contains at most 2,000 most recent TWAP slice fills. Older slices beyond that window are not retrievable from this endpoint.
TWAP slice fills have a hash of all zeros - use that, or the presence of twapId, to distinguish them from regular fills.
Use userFillsByTime when you want all fills (regular + TWAP slices) for a wallet within a time window; each TWAP slice there carries the same twapId field.

Returns a single user’s most recent TWAP slice fills - each individual slice executed as part of a larger TWAP (Time-Weighted Average Price) order. Every entry is a {fill, twapId} pair, where twapId ties the slice back to its parent TWAP order. Multiple slices from the same TWAP share the same twapId. User-keyed. Use this when you want execution-quality data for TWAP orders specifically - slippage per slice, fills-per-TWAP, realized average price - rather than the unified fills feed from userFillsByTime.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userTwapSliceFills"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userTwapSliceFills",
    "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userTwapSliceFills",
    user: "0x31ca8395cf837de08b24da3f660e77761dfb974b",
  }),
});

const slices = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userTwapSliceFills",
        "user": "0x31ca8395cf837de08b24da3f660e77761dfb974b",
    },
)

slices = response.json()

Response

An array of TWAP slice fill objects, most recent first.

[
  {
    "fill": {
      "closedPnl": "0.0",
      "coin": "AVAX",
      "crossed": true,
      "dir": "Open Long",
      "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "oid": 90542681,
      "px": "18.435",
      "side": "B",
      "startPosition": "26.86",
      "sz": "93.53",
      "time": 1681222254710,
      "fee": "0.01",
      "feeToken": "USDC",
      "tid": 118906512037719
    },
    "twapId": 3156
  }
]

Field descriptions

Note: All numeric fill fields (px, sz, startPosition, closedPnl, fee) are returned as decimal strings, preserving upstream precision. Do not parse them as floats - keep them as strings or use a fixed-precision decimal type.

Field	Type	Description
`fill`	`object`	The slice’s fill payload - the same shape as one entry from `userFillsByTime`.
`fill.coin`	`string`	Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`).
`fill.px`	`string`	Fill execution price for this slice.
`fill.sz`	`string`	Slice fill size.
`fill.side`	`string`	`"B"` for buy/long, `"A"` for ask/short.
`fill.time`	`int`	Unix timestamp in milliseconds when the slice executed.
`fill.startPosition`	`string`	Signed position size on the same coin immediately before this slice.
`fill.dir`	`string`	Human-readable direction label - e.g. `"Open Long"`, `"Close Short"`, `"Buy"`, `"Sell"`.
`fill.closedPnl`	`string`	Realized PnL in USDC attributable to this slice (zero when the slice opens or extends a position).
`fill.hash`	`string`	All-zero (`0x000…000`) for TWAP slice fills - the distinguishing marker versus regular fills, which carry an L1 transaction hash.
`fill.oid`	`int`	Order ID for the slice.
`fill.tid`	`int`	Unique trade ID for the slice.
`fill.crossed`	`boolean`	`true` when the slice came from the taker side, `false` when it was the maker side.
`fill.fee`	`string`	Trading fee paid for this slice, denominated in `feeToken`.
`fill.feeToken`	`string`	Symbol the fee was paid in - typically `"USDC"`.
`twapId`	`int`	Identifier of the parent TWAP order. Multiple slice fills from the same TWAP share this value - group by `twapId` to reconstruct per-TWAP execution.

userFills

fetch a user’s most recent trade fills without specifying a time window.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

builderFills

fetch a builder’s most recent attributed trade fills for revenue attribution and order-flow analytics.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution. Last reviewed: 2026-06-13

userVaultEquities | Hyperliquid Info API

Credit Cost: 1 per call Processing: Realtime The Hyperliquid info endpoint with type: "userVaultEquities" is used to fetch a user’s locked vault equity positions across all vaults they have deposited into.

Note: - Wire-equal to POST api.hyperliquid.xyz/info with {"type": "userVaultEquities", "user": "..."}.

For real-time push of vault deposit, withdrawal, and distribution events, subscribe to walletTxs and read LedgerVaultDeposit, LedgerVaultWithdraw, and LedgerVaultDistribution entries.

Returns the wallet’s per-vault equity: one entry per vault the user has deposited into, with the locked amount and the timestamp at which that equity becomes unlockable. User-keyed. The result is [] for wallets that haven’t deposited into any vault.

Endpoint

POST https://hypercore.goldrushdata.com/info
Authorization: Bearer
Content-Type: application/json

Request

Parameter	Type	Required	Description
`type`	`string`	Yes	Always `"userVaultEquities"`.
`user`	`string`	Yes	The wallet address (lowercase 0x-prefixed hex).

Example

cURL

curl -X POST https://hypercore.goldrushdata.com/info \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "userVaultEquities",
    "user": "0x2b804617c6f63c040377e95bb276811747006f4b"
  }'

TypeScript

const response = await fetch("https://hypercore.goldrushdata.com/info", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    type: "userVaultEquities",
    user: "0x2b804617c6f63c040377e95bb276811747006f4b",
  }),
});

const equities = await response.json();

Python

import os, requests

response = requests.post(
    "https://hypercore.goldrushdata.com/info",
    headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
    json={
        "type": "userVaultEquities",
        "user": "0x2b804617c6f63c040377e95bb276811747006f4b",
    },
)

equities = response.json()

Response

An array of vault equity entries.

[
  {
    "vaultAddress": "0x1962905b0a2d0ce8907a92ed5f7a17fef3e1b53e",
    "equity": "5000.50",
    "lockedUntilTimestamp": 1741132800000
  }
]

Field descriptions

Note: equity is returned as a decimal string, preserving upstream precision. Do not parse it as a float - keep it as a string or use a fixed-precision decimal type.

Field	Type	Description
`vaultAddress`	`string`	Vault contract address (0x-prefixed hex).
`equity`	`string`	User’s equity in this vault, in USD.
`lockedUntilTimestamp`	`int`	Unix timestamp in milliseconds at which this equity becomes unlockable.

userFills

fetch a user’s most recent trade fills without specifying a time window.

userFillsByTime

fetch a user’s trade fills within a time window for P&L recaps and tax ledger reconstruction.

userFunding

fetch a user’s per-coin funding payment history within a time window for funding-only P&L attribution.

userNonFundingLedgerUpdates

fetch a user’s USDC and account ledger history within a time window, excluding funding payments, for… Last reviewed: 2026-06-13

​Hyperliquid Info API

​Available Types (today)

​Migration Pattern

​Endpoint

​Comparison with the public Hyperliquid API

​Available types

​Market metadata

​User account state

​User history

​Vaults & staking

​Builder activity

​GoldRush-native batch

​How clients see it

​Errors

​Networks

​Next

​Migration guide

​SDK compatibility

​Limits and caching

​API reference

​Side-by-side

​cURL

​JavaScript / TypeScript

​Python

​Behavioral notes

​Response is byte-equal, modulo live drift

​Unsupported types return a JSON error

​Auth errors return JSON

​Existing SDKs work after a baseUrl override

​Authentication

​What you gain

​JavaScript / TypeScript: nomeida/hyperliquid

​Install

​Configure

​Header injection fallback

​Python: hyperliquid-dex/hyperliquid-python-sdk

​Install

​Configure

​Verification

​Other SDKs

​No rate limits

​How caching works

​Recommended polling cadences

​Watch out for client-side limits

​Network and TLS

​Need higher guarantees?

​Hyperliquid Info API Reference

​batchClearinghouseState | Hyperliquid Info API

​Endpoint

​Request

​Example

​Response

​All success

​Mixed result (one wallet failed)

​Per-wallet error slot

​clearinghouseState slot field reference

​clearinghouseState field reference

​Related endpoints

​batchSpotClearinghouseState

​clearinghouseState

​spotClearinghouseState

​batchSpotClearinghouseState | Hyperliquid Info API

​Endpoint

​Request

​Example

​Response

​All success

​Mixed result (one wallet failed)

​Per-wallet error slot

​spotClearinghouseState slot field reference

​spotClearinghouseState field reference

​Related endpoints

​batchClearinghouseState

​spotClearinghouseState

​clearinghouseState

​spotMeta

​builderFillsByTime | Hyperliquid Info API

​Endpoint

​Request

​Example

Hyperliquid Info API

Available Types (today)

Migration Pattern

Endpoint

Comparison with the public Hyperliquid API

Available types

Market metadata

User account state

User history

Vaults & staking

Builder activity

GoldRush-native batch

How clients see it

Errors

Networks

Next

Migration guide

SDK compatibility

Limits and caching

API reference

Side-by-side

cURL

JavaScript / TypeScript

Python

Behavioral notes

Response is byte-equal, modulo live drift

Unsupported types return a JSON error

Auth errors return JSON

Existing SDKs work after a `baseUrl` override

Authentication

What you gain

JavaScript / TypeScript: `nomeida/hyperliquid`

Install

Configure

Header injection fallback

Python: `hyperliquid-dex/hyperliquid-python-sdk`

Install

Configure

Verification

Other SDKs

No rate limits

How caching works

Recommended polling cadences

Watch out for client-side limits

Network and TLS

Need higher guarantees?

Hyperliquid Info API Reference

batchClearinghouseState | Hyperliquid Info API

Endpoint

Request

Example

Response

All success

Mixed result (one wallet failed)

Per-wallet error slot

clearinghouseState slot field reference

clearinghouseState field reference

Related endpoints

batchSpotClearinghouseState

clearinghouseState

spotClearinghouseState

batchSpotClearinghouseState | Hyperliquid Info API

Endpoint

Request

Example

Response

All success

Mixed result (one wallet failed)

Per-wallet error slot

spotClearinghouseState slot field reference

spotClearinghouseState field reference

Related endpoints

batchClearinghouseState

spotClearinghouseState

clearinghouseState

spotMeta

builderFillsByTime | Hyperliquid Info API

Endpoint

Request

Example