# Hyperliquid Native Perps: BTC, ETH, SOL, HYPE Oracle and Funding | Bitquery Data Store

Oracle price, mark price and hourly funding rate history for BTC, ETH, SOL, HYPE, XRP, DOGE and every other validator-operated HyperCore perp, block by block.

Dataset page: https://bitquery.io/datastore/datasets/hyperliquid-native-perps
Network: Hyperliquid
Category: Events, Orders
Tables: 3
Columns: 50
Coverage: first block to 2026-11-05
Rows: about 3.1B
Size: about 12 GB
Format: Apache Parquet, ZSTD compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

Native HyperCore perps are the markets the Hyperliquid validator set operates itself: BTC, ETH, SOL, HYPE, XRP, DOGE, ZEC, XMR, WLD, RUNE, TRUMP, LINK, NEAR, kPEPE and about 220 others (Market_Protocol = hypercore), as opposed to HIP-3 markets deployed by third parties. Their oracle is not published as a HyperCore event stream; it lives in the signed consensus actions that go into each block. This dataset parses those actions. native_price_updates is the SetGlobalAction the engine applies roughly every 40 to 50 blocks: one row per native market per push, with the oracle price and the mark price the engine set, the external perp price, and the block, consensus round and proposer. native_oracle_votes is each validator's validatorL1UpdateReferenceOracle submission: one row per validator, market and vote, so the aggregated oracle can be checked against its inputs. native_perp_fundings is the hourly settlement: one row per account and native market with the rate, signed position and USDC paid or received.

Every row carries Block_Number and Block_Time (epoch nanoseconds, UTC). Price rows also carry Bundle_Index and Action_Index, the position of the action inside the block, so ordering is deterministic down to the action. Prices are decimal strings exactly as the node recorded them; addresses are 0x-prefixed hex. HIP-3 markets are not in this dataset; their oracle and mark prices are in Hyperliquid Order Book.

## What people use it for

- Hyperliquid funding rate history for BTC, ETH, SOL, HYPE and XRP perps, reproduced from the oracle price in force at each settlement block
- Oracle versus mark price divergence on BTC and ETH perps at ~3-second resolution
- Validator oracle vote dispersion: which validator submitted which BTC or ETH price, block by block
- Funding paid and received per wallet on native perps, joined on Block_Number with the oracle push that preceded the settlement
- Carry and basis backtests on DOGE, ZEC, XMR, WLD, TRUMP, LINK and the long tail of native markets

## Tables (3)

### native_price_updates: 19 columns

One row per native perp market per SetGlobalAction push: the oracle and mark price the engine set, with block, round, proposer and action position.

Bucket prefix: hyperliquid/native_price_updates
File naming: <start_block>_<end_block>.parquet, 1000 blocks per file
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/hyperliquid/native_price_updates/1209500000_1209500999.parquet
Sample updated: Nov 6, 2026

| column | type | description |
| --- | --- | --- |
| Block_Number | Int64 | HyperCore block number; the join key across the Hyperliquid datasets |
| Block_Time | Int64 | Consensus block time, epoch nanoseconds, UTC |
| Block_Date | Date | Block date, UTC |
| Consensus_Round | Int64 | Consensus round that produced the block; runs ahead of Block_Number because empty rounds produce no block |
| Consensus_Proposer | String | Validator that proposed the block, 0x-prefixed hex |
| Bundle_Index | Int64 | Position of the action bundle inside the block, from 0 |
| Action_Index | Int64 | Position of the action inside its bundle, from 0; with Block_Number and Bundle_Index gives a total order |
| Action_Signer | String | Account the engine resolved as the actor of the SetGlobalAction, 0x-prefixed hex |
| Action_Nonce | Int64 | Action nonce, epoch milliseconds by convention |
| Action_Status | String | Engine verdict on the action: ok or err |
| Asset_Index | Int64 | Position of the market in the HyperCore perp universe (0 = BTC, 1 = ETH); the raw key the action uses |
| Market_Coin | String | Market name resolved from Asset_Index, such as BTC or ETH |
| Market_Kind | String | Always perp |
| Market_Protocol | String | Always hypercore (validator-operated market) |
| Oracle_Px | Decimal | Oracle price the engine set for the market in this push, decimal string |
| Mark_Px | Decimal | Mark price the engine set for the market in this push, decimal string |
| ExternalPerp_Px | Decimal | External perp reference price carried in the same action, decimal string; empty when none |
| UsdtUsdc_Px | Decimal | USDT/USDC price carried in the same action, decimal string |
| Native_Px | Decimal | HYPE price carried in the same action, decimal string |

### native_oracle_votes: 17 columns

One row per validator, native market and validatorL1UpdateReferenceOracle submission: the price that validator voted, with block, round and action position.

Bucket prefix: hyperliquid/native_oracle_votes
File naming: <start_block>_<end_block>.parquet, 1000 blocks per file
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/hyperliquid/native_oracle_votes/1209500000_1209500999.parquet
Sample updated: Nov 6, 2026

| column | type | description |
| --- | --- | --- |
| Block_Number | Int64 | HyperCore block number; the join key across the Hyperliquid datasets |
| Block_Time | Int64 | Consensus block time, epoch nanoseconds, UTC |
| Block_Date | Date | Block date, UTC |
| Consensus_Round | Int64 | Consensus round that produced the block |
| Consensus_Proposer | String | Validator that proposed the block, 0x-prefixed hex |
| Bundle_Index | Int64 | Position of the action bundle inside the block, from 0 |
| Action_Index | Int64 | Position of the action inside its bundle, from 0 |
| Validator | String | Validator account that submitted the vote, 0x-prefixed hex |
| Action_Nonce | Int64 | Action nonce, epoch milliseconds by convention |
| Action_Status | String | Engine verdict on the action: ok or err |
| Market_Coin | String | Market name as the validator named it, such as BTC or ETH |
| Market_Kind | String | Always perp |
| Market_Protocol | String | Always hypercore |
| Oracle_Px | Decimal | Oracle price this validator submitted for the market, decimal string |
| ExternalPerp_Px | Decimal | External perp price this validator submitted, decimal string; empty when none |
| UsdtUsdc_Px | Decimal | USDT/USDC price in the vote's scalar updates, decimal string |
| Native_Px | Decimal | HYPE price in the vote's scalar updates, decimal string |

### native_perp_fundings: 14 columns

One row per account and native perp market at each hourly funding settlement: rate, signed position and USDC paid or received.

Bucket prefix: hyperliquid/native_perp_fundings
File naming: <start_block>_<end_block>.parquet, 1000 blocks per file; one file per settlement hour
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/hyperliquid/native_perp_fundings/1209446000_1209446999.parquet
Sample updated: Nov 6, 2026

| column | type | description |
| --- | --- | --- |
| ChainId | String | Chain identifier, always hyperliquid-core |
| Block_Number | UInt64 | Settlement block number; the join key to the price tables |
| Block_Time | Int64 | Block time, epoch nanoseconds, UTC |
| Block_Date | Date | Block date, UTC |
| Funding_Trader_Address | String | Account address, 0x-prefixed hex |
| Funding_Market_Symbol | String | Readable market name, such as BTC |
| Funding_Market_Kind | String | Always perp |
| Funding_Market_Protocol | String | Always hypercore |
| Funding_Market_CoinRaw | String | Market as the node names it; equals Market_Coin in the price tables |
| Funding_Market_IsPerp | Bool | Always 1 |
| Funding_Market_MaxLeverage | UInt32 | Maximum leverage on the market (40 means 40x); 0 when unknown |
| Funding_Amount | Decimal | USDC received by the account, negative when it paid, decimal string |
| Funding_Rate | Decimal | Signed hourly funding rate applied, decimal string |
| Funding_Size | Decimal | Signed position size the rate applied to, negative for a short, decimal string |

## Price

- Latest month (Oct 5, 2026 → Nov 5, 2026): $400 one-time, USD

One-time purchase. The files are yours to keep under the licence above.

## Questions buyers ask

Q: What is included?
A: Three Parquet tables from HyperCore consensus data: native_price_updates (19 columns), native_oracle_votes (17 columns) and native_perp_fundings (14 columns). All native perp markets, every block in the window. Each row carries Block_Number, so the tables join with each other and with the Hyperliquid Trades and Order Book datasets.

Q: Which markets are covered?
A: Every validator-operated HyperCore perp, about 235 markets in November 2026. By fills on 5 November 2026 the busiest were RUNE, ZEC, HYPE, WLD, BTC, LIT, ETH, SOL, TRUMP, INIT, XMR, NEAR, kPEPE, ICP, INJ and XRP; by notional BTC and ETH lead. Delisted markets such as MATIC carry no price and are omitted. HIP-3 markets (xyz:, io:, para: and the other deployer prefixes) are not included.

Q: Which oracle price does funding use?
A: HyperCore settles funding once an hour at the first block after the hour. The oracle price in force at that block is the last native_price_updates row for that market with Block_Number at or below the settlement Block_Number in native_perp_fundings. Join on Market_Coin = Funding_Market_CoinRaw. The validator votes behind that push are in native_oracle_votes at the same blocks.

Q: Where does the price come from?
A: From the signed actions in the consensus stream (replica_cmds), not from the event streams, API snapshots or inferred from payments. SetGlobalAction is the engine's own oracle and mark price write; validatorL1UpdateReferenceOracle is each validator's submitted vote. The raw action is parsed verbatim; Consensus_Round, Consensus_Proposer, Bundle_Index and Action_Index say exactly where in the block it sat.

Q: What are the known gaps?
A: Our raw block archive has short holes. For the 30 days to 5 November 2026 they are: about 70 minutes on 8 to 9 October (blocks 1176454000 to 1176512999), and single 1,000-block holes (about 70 seconds each) on 7, 10 and 25 October plus five consecutive ones on 14 October. Blocks inside a hole are absent from all three tables; a hole never lands on a funding settlement block in that window. Gaps cannot be recovered after the fact, so the delivery manifest lists them explicitly.

Q: How is Asset_Index mapped to a coin?
A: SetGlobalAction lists prices by position in the HyperCore perp universe (0 = BTC, 1 = ETH, 2 = ATOM and so on). We resolve the position to Market_Coin using the universe as published by the node, and keep Asset_Index so the mapping can be checked. Delisted positions carry no price and are omitted.

Q: How big is it?
A: For a measured 1,000-block pack on 5 November 2026: 3,938 price rows (22 pushes), 72,336 vote rows (411 votes) and, at a settlement block the same morning, 310,226 funding rows across 179 native markets. Scaled to 30 days that is roughly 150 million price rows, 2.7 billion vote rows and 220 million funding rows, around 12 GB of ZSTD Parquet in total. These are estimates; exact counts and sizes come with the delivery manifest.

Q: How far back does it go?
A: 30 days up to the day before we prepare the files. HyperCore history is kept as a rolling window, and there is no longer window to buy. For a continuous feed beyond that, ask about the live stream.

Q: How do I load a file?
A: With DuckDB: SELECT * FROM read_parquet('native_price_updates/*.parquet'). With pandas: pd.read_parquet('native_price_updates/'). Parse Oracle_Px, Mark_Px, Funding_Amount, Funding_Rate and Funding_Size with Decimal rather than float; they are stored as decimal strings on purpose.

Q: How is it delivered?
A: As flat Parquet files, one folder per table, one file per 1,000-block pack, with a JSON manifest listing every file, its sha256 and the block holes. We prepare the files within 7 business days of purchase. You choose at checkout where to collect them: a Requester Pays S3 bucket, downloaded with your own AWS account, or a Cloudflare R2 bucket with a read-only API key and no egress fees. Files stay available for 7 days from delivery.

Q: What is not included?
A: HIP-3 markets (their oracle and mark prices are in Hyperliquid Order Book), fills, order and book data, spot and outcome markets, and ledger events.

## Data after your purchase

A purchase is a one-time set of files, up to the coverage end date on the dataset page. For data after that:

- Real-time stream: Kafka Streams sends new Hyperliquid data as it happens. Enterprise plan. Topics and schema: https://docs.bitquery.io/docs/streams/kafka-streaming-concepts/#hyperliquid-hyperliquid
- Daily warehouse tables: Datashares refreshes tables daily in Snowflake, BigQuery, S3 or Azure. Enterprise plan. https://bitquery.io/products/datashares
- Another one-off slice (other chains, tables or dates): a custom extract. https://bitquery.io/products/data-on-demand

## What this file is, and is not

This is a description of one dataset sold by Bitquery, written for assistants and for people. It lists every column but holds no data rows. The sample files linked under each table are real Parquet and are free to download. Figures here come from the product record and are exact unless marked otherwise; the delivery manifest is authoritative for a purchased file. If a question needs a row that is not in a sample, say so rather than guessing at it.