# Robinhood Chain | Bitquery Data Store

Robinhood Chain since its first block of April 2026 as flat Parquet: internal calls, decoded events, transfers, DEX swaps on Uniswap, Pons and other venues, and token balances, at block resolution.

Dataset page: https://bitquery.io/datastore/datasets/robinhood
Network: Robinhood Chain
Category: Calls, Events, Transfers, Trades, Balances
Tables: 5
Columns: 174
Coverage: 2026-04-30 to 2026-10-04
Format: Apache Parquet, ZSTD compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

Five flat Parquet tables covering Robinhood Chain from its first block to yesterday, at block resolution: calls, events, transfers, dex_trades and balances. Calls, events, transfers and dex_trades carry Block_Number, Block_Time and Transaction_Hash, so they join without a lookup table; balances is a snapshot keyed by address and token.

Robinhood Chain is an EVM network, chain id 4663, so these tables use the same schema as our other EVM chains and a job written against Ethereum reads them without changes. The chain produced its first block on 30 April 2026, which makes the Full tier a record of the chain so far rather than a slice of a long past.

The busiest venues are Uniswap v4, Uniswap v3 and the Pons bonding-curve launchpad, and all of them appear in dex_trades under their own Trade_Dex_ProtocolFamily, alongside PancakeSwap Infinity and Aerodrome. Gas is paid in ETH, and native rows carry the symbol ETH; in balances, native ETH has Currency_SmartContract 0x.

## What people use it for

- Full-chain analytics on a new L2 without running a node, from the first block
- Launchpad and DEX research across Pons, Uniswap v4 and v3 in one trades table
- Holder and distribution analysis from the balances snapshot, without rebuilding balances from transfers
- Contract forensics on decoded internal calls and events for any contract on the chain

## Tables (5)

### calls: 41 columns

One row per call frame, internal calls included, with decoded signature, arguments, returns, gas and state changes.

Bucket prefix: robinhood/calls
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/calls/56600000_56600049.parquet
Sample updated: Sep 7, 2026

| column | type | description |
| --- | --- | --- |
| Arguments | String | Decoded call arguments as a JSON array, when the signature resolved; empty otherwise |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Call_CallPath | Array | Path of call indexes from the transaction root down to this frame, as an array of integers |
| Call_CallerIndex | Int32 | Call_Index of the calling frame; -1 for the top-level call |
| Call_Create | String | Whether this frame deployed a contract; true or false |
| Call_Delegated | String | Whether the frame ran through delegatecall, as proxies do; true or false |
| Call_Depth | UInt32 | Nesting depth, 0 for the top-level call |
| Call_EnterIndex | UInt32 | Order in which the frame was entered within the transaction |
| Call_Error | String | Error the call returned; empty on success |
| Call_ExitIndex | UInt32 | Order in which the frame was exited |
| Call_From | String | Calling address, 0x-prefixed |
| Call_Gas | UInt64 | Gas supplied to the call |
| Call_GasUsed | UInt64 | Gas consumed by this call and everything beneath it |
| Call_Index | UInt32 | Position of the frame within the transaction. Events reference it to name the frame that emitted a log |
| Call_Input | String | Raw calldata passed to the frame, hex |
| Call_InternalCalls | UInt32 | Number of calls made beneath this frame |
| Call_LogCount | UInt32 | Number of logs this frame emitted |
| Call_Opcode_Code | UInt32 | Numeric opcode that produced the frame |
| Call_Opcode_Name | String | Opcode name, for example CALL, DELEGATECALL, STATICCALL, CREATE or CREATE2 |
| Call_Output | String | Raw return data, hex |
| Call_Reverted | String | Whether the frame reverted; true or false. A frame can revert inside a transaction that succeeded |
| Call_SelfDestruct | String | Whether the called contract self-destructed; true or false |
| Call_Signature_Abi | String | ABI fragment for the resolved function; empty when the selector is unknown |
| Call_Signature_Name | String | Function name, when resolved |
| Call_Signature_Parsed | String | Human-readable form of the call: function name with argument values filled in |
| Call_Signature_Signature | String | Canonical function signature, for example transfer(address,uint256) |
| Call_Signature_SignatureHash | String | Four-byte function selector, hex |
| Call_Signature_SignatureType | String | How the signature was resolved, for example from a verified ABI or a public selector registry |
| Call_Success | String | Whether the frame succeeded; true or false |
| Call_To | String | Called address, 0x-prefixed |
| Call_Value | String | Native ETH sent with the call, decimal adjusted, as a decimal string |
| Call_ValueInUSD | Float64 | That value in USD at the block's hourly ETH price; 0 when the value is 0 |
| Returns | String | Decoded return values as JSON, when the signature resolved; empty otherwise |
| StateChanges | String | Storage and balance changes the frame produced, as JSON |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| TransactionStatus_EndError | String | Error the parent transaction ended with; empty when it succeeded |
| TransactionStatus_FaultError | String | Fault-level error on the parent transaction; empty when none |
| TransactionStatus_Success | String | Whether the parent transaction succeeded; true or false |

### events: 45 columns

One row per log, with the decoded event signature, topics, raw data and the call frame that emitted it.

Bucket prefix: robinhood/events
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/events/56600000_56600049.parquet
Sample updated: Sep 7, 2026

| column | type | description |
| --- | --- | --- |
| Arguments | String | Decoded event arguments as a JSON array, when the signature resolved; empty otherwise |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Call_CallPath | Array | Path of call indexes from the transaction root down to the emitting frame |
| Call_CallerIndex | Int32 | Call_Index of the frame that called the emitting frame; -1 at the top level |
| Call_Create | String | Whether the emitting frame deployed a contract; true or false |
| Call_Error | String | Error the emitting frame returned; empty on success |
| Call_From | String | Caller of the emitting frame, 0x-prefixed |
| Call_Gas | UInt64 | Gas supplied to the emitting frame |
| Call_GasUsed | UInt64 | Gas consumed by the emitting frame and everything beneath it |
| Call_Index | UInt32 | Position of the emitting frame within the transaction; join to calls on this plus Transaction_Hash |
| Call_InternalCalls | UInt32 | Number of calls made beneath the emitting frame |
| Call_Reverted | String | Whether the emitting frame reverted; true or false |
| Call_SelfDestruct | String | Whether the emitting contract self-destructed; true or false |
| Call_Signature_Abi | String | ABI fragment of the function the emitting frame ran |
| Call_Signature_Name | String | Name of that function, when resolved |
| Call_Signature_Signature | String | Canonical signature of that function |
| Call_Signature_SignatureHash | String | Four-byte selector of that function, hex |
| Call_Signature_SignatureType | String | How that function signature was resolved |
| Call_To | String | Address the emitting frame called, 0x-prefixed |
| Call_Value | String | Native ETH sent with the emitting frame, decimal adjusted |
| ChainId | UInt64 | EVM chain id; 4663 for Robinhood Chain mainnet |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in ETH. It repeats on every log of the transaction, so count it once per transaction |
| Log_EnterIndex | UInt32 | Enter index of the emitting frame |
| Log_ExitIndex | UInt32 | Exit index of the emitting frame |
| Log_Index | UInt32 | Position of the log within the transaction |
| Log_LogAfterCallIndex | UInt32 | Index of the last call frame entered before this log, for ordering logs against calls |
| Log_Pc | UInt64 | Program counter at which the log opcode ran |
| Log_Signature_Abi | String | ABI fragment for the resolved event; empty when the topic is unknown |
| Log_Signature_Name | String | Event name, for example Transfer or Swap, when resolved |
| Log_Signature_Signature | String | Canonical event signature, for example Transfer(address,address,uint256) |
| Log_Signature_SignatureHash | String | Keccak hash of the event signature, hex; the same value as topic 0 |
| Log_Signature_SignatureType | String | How the event signature was resolved |
| Log_SmartContract | String | Contract that emitted the log, 0x-prefixed. Filter on this for one contract's events |
| LogHeader_Address | String | Address recorded in the log header, 0x-prefixed |
| LogHeader_Data | String | Raw non-indexed log data, hex |
| LogHeader_Index | UInt64 | Index of the log within the block, as the receipt records it |
| LogHeader_Removed | String | Whether the log was removed by a reorg; true or false |
| Topics_Hash | Array | Indexed topics of the log, as an array of hex strings; the first is the event signature hash |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| Transaction_To | String | Address the transaction called, 0x-prefixed |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |

### transfers: 24 columns

One row per native ETH or token transfer on Robinhood Chain, with sender, receiver, token metadata and a USD value where a price exists.

Bucket prefix: robinhood/transfers
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/transfers/56600000_56600049.parquet
Sample updated: Sep 7, 2026

| column | type | description |
| --- | --- | --- |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in ETH, as a decimal string. It repeats on every row of the transaction, so count it once per transaction |
| Transaction_Hash | String | Hash of the transaction this row settled in, 0x-prefixed; the join key to transactions and logs |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| TransactionStatus_Success | String | Whether the transaction succeeded; the string true or false. Failed transactions are kept |
| Transaction_Type | UInt32 | EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702; Arbitrum-stack system transactions use types above 100 |
| Transfer_Amount | String | Amount moved, decimal adjusted, as a decimal string with exactly as many places as the token has decimals. Multiply by 10 to the power of the decimals for the raw on-chain integer |
| Transfer_AmountInUSD | Float64 | Amount valued in USD at the hourly price for the block's hour; 0 when the amount is 0 or the token has no price |
| Transfer_Currency_Decimals | Int32 | Decimals of the transferred currency, as its contract reports them |
| Transfer_Currency_DelegatedTo | String | Implementation address for proxy tokens; the string 0x when there is none |
| Transfer_Currency_Fungible | String | Whether the currency is fungible; the string true or false, and false for NFTs |
| Transfer_Currency_Name | String | Name reported by the contract; lookalike tokens copy real names |
| Transfer_Currency_Native | String | true for native ETH, false for tokens. Filter on this column to separate ETH movement from token movement |
| Transfer_Currency_ProtocolName | String | Token standard, for example erc20 or erc721; empty for native ETH |
| Transfer_Currency_SmartContract | String | Contract of the transferred token, 0x-prefixed; the string 0x for native ETH |
| Transfer_Currency_Symbol | String | Symbol reported by the contract; repeats across tokens, so join on the contract address |
| Transfer_Id | String | Token id for NFT transfers; the string 0 for fungible transfers |
| Transfer_Index | UInt32 | Position within the transaction. Several rows in one transaction can share it |
| Transfer_Sender | String | Sending address, 0x-prefixed |
| Transfer_Receiver | String | Receiving address, 0x-prefixed |
| Transfer_Type | String | token for token transfers, transaction for a plain ETH send, call for ETH moved by a contract in an internal call |
| Transfer_URI | String | Metadata URI for NFT transfers; empty otherwise |

### dex_trades: 53 columns

One row per DEX swap on Robinhood Chain, Uniswap v4, v3 and v2, the Pons bonding curves, PancakeSwap Infinity and Aerodrome included, with both sides, pool and protocol and a USD value where a price exists.

Bucket prefix: robinhood/dex_trades
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/dex_trades/56600000_56600049.parquet
Sample updated: Sep 7, 2026

| column | type | description |
| --- | --- | --- |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in ETH, as a decimal string. It repeats on every row of the transaction, so count it once per transaction |
| Trade_Buy_Amount | String | Amount bought, decimal adjusted, as a decimal string with exactly as many places as the token has decimals; for NFTs, the number of items |
| Trade_Buy_AmountInUSD | Float64 | USD value of the swap at the block's hourly price, set from its best-priced side and the same on both sides; 0 when neither side has a price |
| Trade_Buy_Buyer | String | Address that received the bought currency, usually a router or the trader |
| Trade_Buy_Currency_Decimals | Int32 | Decimals of the bought token, as its contract reports them |
| Trade_Buy_Currency_Fungible | String | Whether the bought token is fungible; true or false, and false for NFTs |
| Trade_Buy_Currency_HasURI | String | Whether the bought token carries a metadata URI; true or false |
| Trade_Buy_Currency_Name | String | Name reported by the bought token's contract; lookalike tokens copy real names |
| Trade_Buy_Currency_ProtocolName | String | Token standard on the bought side, for example erc20 or erc1155; empty for native ETH |
| Trade_Buy_Currency_SmartContract | String | Contract of the bought token, 0x-prefixed; the string 0x for native ETH |
| Trade_Buy_Currency_Symbol | String | Symbol reported by the bought token's contract; not unique, so join on the contract |
| Trade_Buy_Ids | Array | Token ids bought, as strings; empty for fungible tokens |
| Trade_Buy_OrderId | String | Order id for order-book and marketplace trades such as Seaport, hex without 0x; empty for pool swaps. The same value on both sides |
| Trade_Buy_Price | Float64 | Price of the bought currency in units of the sold currency |
| Trade_Buy_PriceInUSD | Float64 | USD price of one unit of the bought currency: the swap's USD value divided by the bought amount, so per item for NFTs; 0 when unpriced |
| Trade_Buy_Seller | String | Address that sent the bought currency, usually the pool |
| Trade_Dex_DelegatedTo | String | Implementation the DEX contract delegates to, when it is a proxy; 0x otherwise |
| Trade_Dex_OwnerAddress | String | Factory or owner the index records for the pool, 0x-prefixed; the string 0x when none. Use it to tell forks apart |
| Trade_Dex_Pair_Decimals | Int32 | Decimals of the pool's own LP token; 0 when the pool has none, as in v3 and v4 |
| Trade_Dex_Pair_Name | String | Name of the pool's own LP token, for example Uniswap V2; empty for v3, v4 and other pools without one |
| Trade_Dex_Pair_SmartContract | String | Pool token contract for v2-style pools, 0x-prefixed; the string 0x otherwise, where Trade_Dex_SmartContract or Trade_PoolId names the pool |
| Trade_Dex_Pair_Symbol | String | Symbol of the pool's own LP token, for example UNI-V2; not unique |
| Trade_Dex_ProtocolFamily | String | Protocol family, for example Uniswap, Pons, PancakeSwapInfinity or Aerodrome. Filter this column to keep or drop a venue |
| Trade_Dex_ProtocolName | String | Protocol and version as indexed, for example uniswap_v3 or seaport_v1.4. It names the pool design, so forks can share it |
| Trade_Dex_ProtocolVersion | String | Protocol version string |
| Trade_Dex_SmartContract | String | Contract that emitted the swap, 0x-prefixed: the pool for v2 and v3 designs, the shared PoolManager for Uniswap v4 and PancakeSwap Infinity, the exchange for marketplaces |
| Trade_Fees | String | Fees charged on the swap as a JSON array of [amount, amountInUSD, [decimals, name, token standard, contract hex, symbol], payer, recipient]; the USD value is set when the fee token is one side of the swap; [] when none |
| Trade_Index | UInt32 | Position of the swap within the transaction |
| Trade_PriceAsymmetry | Float64 | Relative gap between the prices implied by the two sides of the swap; 0 when they agree |
| Trade_Sell_Amount | String | Amount sold, decimal adjusted, as a decimal string with exactly as many places as the token has decimals; for NFTs, the number of items |
| Trade_Sell_AmountInUSD | Float64 | USD value of the swap at the block's hourly price, set from its best-priced side and the same on both sides; 0 when neither side has a price |
| Trade_Sell_Buyer | String | Address that received the sold currency, usually the pool |
| Trade_Sell_Currency_Decimals | Int32 | Decimals of the sold token, as its contract reports them |
| Trade_Sell_Currency_Fungible | String | Whether the sold token is fungible; true or false, and false for NFTs |
| Trade_Sell_Currency_HasURI | String | Whether the sold token carries a metadata URI; true or false |
| Trade_Sell_Currency_Name | String | Name reported by the sold token's contract; lookalike tokens copy real names |
| Trade_Sell_Currency_ProtocolName | String | Token standard on the sold side, for example erc20 or erc1155; empty for native ETH |
| Trade_Sell_Currency_SmartContract | String | Contract of the sold token, 0x-prefixed; the string 0x for native ETH |
| Trade_Sell_Currency_Symbol | String | Symbol reported by the sold token's contract; not unique, so join on the contract |
| Trade_Sell_Ids | Array | Token ids sold, as strings; empty for fungible tokens |
| Trade_Sell_OrderId | String | Order id for order-book and marketplace trades such as Seaport, hex without 0x; empty for pool swaps. The same value on both sides |
| Trade_Sell_Price | Float64 | Price of the sold currency in units of the bought currency |
| Trade_Sell_PriceInUSD | Float64 | USD price of one unit of the sold currency: the swap's USD value divided by the sold amount, so per item for NFTs; 0 when unpriced |
| Trade_Sell_Seller | String | Address that sent the sold currency, usually a router or the trader |
| Trade_Sender | String | Address that called the pool, often a router or aggregator |
| Transaction_From | String | Address that signed the transaction: the trader behind any router |
| Transaction_Hash | String | Hash of the transaction, 0x-prefixed; the join key to transfers and logs |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| Transaction_To | String | Contract the transaction called, often a router |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |

### balances: 11 columns

One row per address and token holding a balance at the end of the file's block range: a snapshot of levels, not deltas, with first and last change times.

Bucket prefix: robinhood/balances
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/balances/56600000_56600049.parquet
Sample updated: Sep 7, 2026

| column | type | description |
| --- | --- | --- |
| Balance_Address | String | Wallet or contract that holds the balance, lower case with 0x |
| Block_Date | Date | UTC date of the block |
| Currency_Name | String | Token name reported by the contract; not unique |
| Currency_SmartContract | String | Token contract, lower case with 0x; 0x for native ETH. The key for joins |
| Currency_Symbol | String | Token symbol reported by the contract; repeats across tokens, so join on the contract |
| Currency_ProtocolName | String | Token standard, erc20 or erc721; empty for native ETH |
| Balance_Amount | String | Balance held at the end of the file's block range, decimal adjusted, as a decimal string |
| Balance_FirstChangeTime | DateTime | First time this address held this token, UTC |
| Balance_LastChangeTime | DateTime | Last time this balance changed, UTC |
| Balance_UpdateCount | UInt64 | Number of balance changes recorded for this address and token |
| Balance_RowCount | UInt64 | Rows aggregated into this snapshot; always 1 |

## Price

- Latest month (Sep 4, 2026 → Oct 4, 2026): $400 one-time, USD
- Full history (Apr 30, 2026 → Oct 4, 2026): $1,000 one-time, USD

Every window includes all 5 tables and 174 columns. Only the time range changes.

## Questions buyers ask

Q: What is included in the Robinhood Chain dataset?
A: Five Parquet tables with 174 documented columns in total: calls (41), events (45), transfers (24), dex_trades (53) and balances (11). Each purchase covers the window you choose, through to yesterday, refreshed daily. The Full tier starts at block 1 on 30 April 2026.

Q: How far back does the full history go?
A: To block 1 on 30 April 2026. Robinhood Chain is months old, so the Full tier is the record of the chain so far, and the 1-month tier is a recent slice of it. Volume in the first weeks looks nothing like volume today; Block_Time makes any cutoff easy to apply.

Q: How large is the full dataset?
A: Calls and events dominate it, as on every EVM chain, with several rows per transaction. We size it per table before delivery and send you the exact figures with the manifest. The balances snapshot is small by comparison: one row per address and token that holds a balance.

Q: How do the tables join?
A: On Transaction_Hash across calls, events, transfers and dex_trades. Within a transaction, Call_Index orders the call frames, Log_Index orders the logs, Transfer_Index orders the transfers and Trade_Index orders the swaps. Balances has no transaction key; join it to the other tables on the address and Currency_SmartContract.

Q: What is the balances table exactly?
A: A snapshot of levels, not a log of changes: for each address and token, the balance held at the end of the file's block range, the first and last time it changed and how many changes it has seen. Native ETH has Currency_SmartContract 0x, and Currency_ProtocolName is erc20, erc721 or empty for ETH. Balance_RowCount is always 1.

Q: What is deliberately not in this dataset?
A: Blocks and transactions tables are not part of this bundle yet, and neither are balance updates. The Pons launchpad has its own pre-filtered dataset in this catalog, which is the same dex_trades and events rows filtered to the Pons factory and curves; buying both is not necessary.

Q: Which DEXes are in dex_trades?
A: Every venue we decode on the chain, identified by Trade_Dex_ProtocolFamily and Trade_Dex_ProtocolName on each row. In the sample window of 50 blocks the names present were uniswap_v4, uniswap_v3, pons_v2, uniswap_v2, pancakeswap_infinity and aerodrome_v1, in that order of volume. Filter the family column to keep or drop a venue.

Q: Does Robinhood Chain have uncles?
A: No. It is an Arbitrum-stack rollup with a single sequencer, so there are no uncle blocks and the uncle fields in the shared EVM schema are 0 throughout. They are kept so a query written against one EVM chain runs unchanged here.

Q: How much of it is valued in USD?
A: Only currencies with an hourly price series are valued, and the dataset says so rather than filling the gap: a USD value of 0 means either a zero-value row or no price, and the column cannot tell the two apart. DEX trades are priced from the safer side of the swap, so most swaps with a stablecoin or ETH on one side carry a value; transfers of long-tail and spam tokens mostly do not.

Q: Are failed transactions included?
A: Yes, throughout, and the export applies no filter of its own. TransactionStatus_Success carries the transaction's outcome on every table that has it. Spam tokens, zero-value rows and lookalike contracts are all kept too; the columns let you drop what you do not want.

Q: How do I get one contract's activity?
A: Filter Call_To in calls and Log_SmartContract in events to the contract, lower case with 0x. For token flow, filter Transfer_Currency_SmartContract in transfers. Join on contract addresses rather than symbols or names; both repeat, and lookalike tokens copy them deliberately.

Q: How are amounts and booleans encoded?
A: Amounts are decimal-adjusted decimal strings, carrying exactly as many places as the token has decimals; multiply by ten to the power of the decimals for the raw on-chain integer. Casting to float loses precision on large values. Booleans are the strings true and false, not 0 and 1, in every column.

Q: How do I load it?
A: One line in DuckDB: SELECT * FROM read_parquet('transfers/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). The sample files open without credentials.

Q: How is the data delivered, and how current is it?
A: As flat Parquet named by block range, 50 blocks per file and sorted ascending, one prefix per table, with a JSON manifest listing every file and its sha256. We prepare the files within 7 business days of purchase and email you the location. 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. Enterprise orders can be delivered into your own S3, GCS or R2 bucket. Refreshed daily with T+1 latency, so a purchase made today includes everything to yesterday.

Q: Can I try before I buy?
A: Yes. Each table links to a public sample file with real records, and the sample bucket holds full Parquet files you can load directly. No email address required.

## 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.