BitqueryBitqueryData Store
Robinhood logoRobinhoodBlocksTransactionsCallsEventsTransfersTradesRewardsBalances

Robinhood Chain

Robinhood Chain since its first block of April 2026 as flat Parquet: blocks, transactions, internal calls, decoded events, transfers, DEX swaps, sequencer rewards and token balances.

Coverage
Apr 30, 2026→ Oct 25, 2026 · yesterday
Tables
8Parquet, one prefix each
Columns
290across 8 tables
Coverage ends yesterday, UTC

Overview

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

Robinhood Chain is an EVM network, chain id 4663, so calls, events, transfers and dex_trades use the same schema as our other EVM chains; transactions and miner_rewards carry the chain's own column set, without the raw signature and calldata fields. 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.

Use cases

  • 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

8 tables

290 columns · free sample for each table

blocks

22 columns

One row per Robinhood Chain block, with the sequencer, gas, base fee and the trie roots.

robinhood/blocks<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Oct 5, 2026

transactions

40 columns

One row per Robinhood Chain transaction, with the fee breakdown, receipt status, call count and outcome.

robinhood/transactions<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Oct 7, 2026

calls

41 columns

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

robinhood/calls<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 7, 2026

events

45 columns

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

robinhood/events<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 7, 2026

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.

robinhood/transfers<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 7, 2026

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.

robinhood/dex_trades<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 7, 2026

miner_rewards

54 columns

One row per block, with the full block header and the sequencer's take split into static, dynamic, transaction-fee and burnt components.

robinhood/miner_rewards<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Oct 7, 2026

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.

robinhood/balances<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 7, 2026

Schema reference

copies a column name
290 columns
blocks22 columnsOne row per Robinhood Chain block, with the sequencer, gas, base fee and the trie roots.
ColumnTypeDescription
Block22
Block_BaseFeeStringEIP-1559 base fee per gas, in ETH, as a decimal string
Block_BaseFeeInUSDFloat64Base fee per gas valued in USD at the block's hourly ETH price; 0 when unpriced
Block_BloomStringBloom filter over the block's logs, hex
Block_CoinbaseStringAddress credited as block producer, 0x-prefixed; on Robinhood Chain this is the sequencer address 0xa4b000000000000000000073657175656e636572 on every block
Block_DateDateUTC date of the block
Block_DifficultyStringDifficulty field as recorded; Robinhood Chain has no proof of work, so it is 1 on every block
Block_GasLimitUInt64Gas limit of the block
Block_GasUsedUInt64Total gas used by the block's transactions
Block_HashStringBlock hash, 0x-prefixed
Block_MixDigestStringMix digest field, hex
Block_NumberUInt64Block height
Block_NonceUInt64Block nonce
Block_ParentHashStringHash of the parent block, 0x-prefixed
Block_ReceiptHashStringRoot of the receipts trie
Block_Result_ErrorsStringErrors recorded while executing the block; empty when there were none
Block_Result_GasUInt64Gas accounted for in the block's execution result
Block_RootStringState root after the block
Block_TimeDateTimeBlock timestamp, UTC
Block_TxCountUInt32Number of transactions in the block
Block_TxHashStringRoot of the transactions trie
Block_UncleHashStringRoot of the uncles list. Robinhood Chain produces no uncles, so this is the empty-list hash on every block
Block_UnclesCountUInt32Number of uncles; always 0 on Robinhood Chain
Sample file
transactions40 columnsOne row per Robinhood Chain transaction, with the fee breakdown, receipt status, call count and outcome.
ColumnTypeDescription
Other1
ChainIdUInt32Robinhood Chain id; always 4663
Block7
Block_DateDateUTC date of the block
Block_TimeDateTimeBlock timestamp, UTC
Block_NumberUInt64Block height
Block_HashStringBlock hash, 0x-prefixed
Block_CoinbaseStringAddress credited as block producer, 0x-prefixed; on Robinhood Chain this is the sequencer address 0xa4b000000000000000000073657175656e636572 on every block
Block_GasUsedUInt64Total gas used by the block's transactions
Block_BaseFeeStringBase fee per gas of the containing block, in ETH, as a decimal string
Transaction14
Transaction_IndexUInt32Position of the transaction within the block
Transaction_HashStringTransaction hash, 0x-prefixed. The join key across every table
Transaction_NonceUInt64Sender's nonce
Transaction_TypeUInt32EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702; Arbitrum-stack system transactions use types above 100
Transaction_FromStringAddress that signed the transaction, 0x-prefixed
Transaction_ToStringAddress the transaction called, 0x-prefixed; the string 0x for a contract deployment
Transaction_ValueStringNative ETH sent with the transaction, decimal adjusted, as a decimal string
Transaction_ValueInUSDFloat64That value in USD at the block's hourly ETH price
Transaction_GasUInt64Gas limit the sender set
Transaction_GasPriceStringGas price the sender offered, as a decimal string
Transaction_GasPriceInUSDFloat64Offered gas price in USD
Transaction_GasFeeCapStringEIP-1559 max fee per gas, as a decimal string
Transaction_GasTipCapStringEIP-1559 max priority fee per gas, as a decimal string
Transaction_CallCountUInt32Number of call frames the transaction produced, the top-level call included. Join to the calls table on Transaction_Hash to read them
Receipt4
Receipt_TypeUInt32Receipt type, mirroring the transaction type
Receipt_StatusUInt32Receipt status: 1 succeeded, 0 failed
Receipt_GasUsedUInt64Gas used by this transaction alone
Receipt_ContractAddressStringAddress of the contract deployed by this transaction, 0x-prefixed; the string 0x when none
Fee11
Fee_SenderFeeStringTotal network fee the sender paid for the transaction, in ETH, as a decimal string
Fee_SenderFeeInUSDFloat64Total sender fee in USD
Fee_MinerRewardStringPortion of the fee paid to the validator, as a decimal string
Fee_MinerRewardInUSDFloat64Validator's share of the fee in USD
Fee_BurntStringETH burnt by the base fee, as a decimal string
Fee_BurntInUSDFloat64Burnt fee in USD at the block's hourly ETH price
Fee_EffectiveGasPriceStringGas price actually charged, in ETH, as a decimal string
Fee_EffectiveGasPriceInUSDFloat64Effective gas price in USD
Fee_PriorityFeePerGasStringPriority fee per gas, in ETH, as a decimal string
Fee_PriorityFeePerGasInUSDFloat64Priority fee per gas in USD
Fee_GasRefundUInt64Gas refunded to the sender, in gas units
TransactionStatus3
TransactionStatus_SuccessStringWhether the transaction succeeded; true or false
TransactionStatus_EndErrorStringError the transaction ended with; empty when it succeeded
TransactionStatus_FaultErrorStringFault-level error raised during execution; empty when none
Sample file
calls41 columnsOne row per call frame, internal calls included, with decoded signature, arguments, returns, gas and state changes.
ColumnTypeDescription
Other3
ArgumentsStringDecoded call arguments as a JSON array, when the signature resolved; empty otherwise
ReturnsStringDecoded return values as JSON, when the signature resolved; empty otherwise
StateChangesStringStorage and balance changes the frame produced, as JSON
Block3
Block_DateDateUTC date of the block
Block_NumberUInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Call24
Call_CallPathArrayPath of call indexes from the transaction root down to this frame, as an array of integers
Call_CallerIndexInt32Call_Index of the calling frame; -1 for the top-level call
Call_CreateStringWhether this frame deployed a contract; true or false
Call_DelegatedStringWhether the frame ran through delegatecall, as proxies do; true or false
Call_DepthUInt32Nesting depth, 0 for the top-level call
Call_EnterIndexUInt32Order in which the frame was entered within the transaction
Call_ErrorStringError the call returned; empty on success
Call_ExitIndexUInt32Order in which the frame was exited
Call_FromStringCalling address, 0x-prefixed
Call_GasUInt64Gas supplied to the call
Call_GasUsedUInt64Gas consumed by this call and everything beneath it
Call_IndexUInt32Position of the frame within the transaction. Events reference it to name the frame that emitted a log
Call_InputStringRaw calldata passed to the frame, hex
Call_InternalCallsUInt32Number of calls made beneath this frame
Call_LogCountUInt32Number of logs this frame emitted
Call_Opcode_CodeUInt32Numeric opcode that produced the frame
Call_Opcode_NameStringOpcode name, for example CALL, DELEGATECALL, STATICCALL, CREATE or CREATE2
Call_OutputStringRaw return data, hex
Call_RevertedStringWhether the frame reverted; true or false. A frame can revert inside a transaction that succeeded
Call_SelfDestructStringWhether the called contract self-destructed; true or false
Call_SuccessStringWhether the frame succeeded; true or false
Call_ToStringCalled address, 0x-prefixed
Call_ValueStringNative ETH sent with the call, decimal adjusted, as a decimal string
Call_ValueInUSDFloat64That value in USD at the block's hourly ETH price; 0 when the value is 0
Call_Signature6
Call_Signature_AbiStringABI fragment for the resolved function; empty when the selector is unknown
Call_Signature_NameStringFunction name, when resolved
Call_Signature_ParsedStringHuman-readable form of the call: function name with argument values filled in
Call_Signature_SignatureStringCanonical function signature, for example transfer(address,uint256)
Call_Signature_SignatureHashStringFour-byte function selector, hex
Call_Signature_SignatureTypeStringHow the signature was resolved, for example from a verified ABI or a public selector registry
Transaction2
Transaction_HashStringHash of the containing transaction, 0x-prefixed. The join key
Transaction_IndexUInt64Position of the transaction within the block
TransactionStatus3
TransactionStatus_EndErrorStringError the parent transaction ended with; empty when it succeeded
TransactionStatus_FaultErrorStringFault-level error on the parent transaction; empty when none
TransactionStatus_SuccessStringWhether the parent transaction succeeded; true or false
Sample file
events45 columnsOne row per log, with the decoded event signature, topics, raw data and the call frame that emitted it.
ColumnTypeDescription
Other2
ArgumentsStringDecoded event arguments as a JSON array, when the signature resolved; empty otherwise
ChainIdUInt64EVM chain id; 4663 for Robinhood Chain mainnet
Block3
Block_DateDateUTC date of the block
Block_NumberUInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Call13
Call_CallPathArrayPath of call indexes from the transaction root down to the emitting frame
Call_CallerIndexInt32Call_Index of the frame that called the emitting frame; -1 at the top level
Call_CreateStringWhether the emitting frame deployed a contract; true or false
Call_ErrorStringError the emitting frame returned; empty on success
Call_FromStringCaller of the emitting frame, 0x-prefixed
Call_GasUInt64Gas supplied to the emitting frame
Call_GasUsedUInt64Gas consumed by the emitting frame and everything beneath it
Call_IndexUInt32Position of the emitting frame within the transaction; join to calls on this plus Transaction_Hash
Call_InternalCallsUInt32Number of calls made beneath the emitting frame
Call_RevertedStringWhether the emitting frame reverted; true or false
Call_SelfDestructStringWhether the emitting contract self-destructed; true or false
Call_ToStringAddress the emitting frame called, 0x-prefixed
Call_ValueStringNative ETH sent with the emitting frame, decimal adjusted
Call_Signature5
Call_Signature_AbiStringABI fragment of the function the emitting frame ran
Call_Signature_NameStringName of that function, when resolved
Call_Signature_SignatureStringCanonical signature of that function
Call_Signature_SignatureHashStringFour-byte selector of that function, hex
Call_Signature_SignatureTypeStringHow that function signature was resolved
Fee1
Fee_SenderFeeStringNetwork fee the sender paid for the whole transaction, in ETH. It repeats on every log of the transaction, so count it once per transaction
Log11
Log_EnterIndexUInt32Enter index of the emitting frame
Log_ExitIndexUInt32Exit index of the emitting frame
Log_IndexUInt32Position of the log within the transaction
Log_LogAfterCallIndexUInt32Index of the last call frame entered before this log, for ordering logs against calls
Log_PcUInt64Program counter at which the log opcode ran
Log_Signature_AbiStringABI fragment for the resolved event; empty when the topic is unknown
Log_Signature_NameStringEvent name, for example Transfer or Swap, when resolved
Log_Signature_SignatureStringCanonical event signature, for example Transfer(address,address,uint256)
Log_Signature_SignatureHashStringKeccak hash of the event signature, hex; the same value as topic 0
Log_Signature_SignatureTypeStringHow the event signature was resolved
Log_SmartContractStringContract that emitted the log, 0x-prefixed. Filter on this for one contract's events
LogHeader4
LogHeader_AddressStringAddress recorded in the log header, 0x-prefixed
LogHeader_DataStringRaw non-indexed log data, hex
LogHeader_IndexUInt64Index of the log within the block, as the receipt records it
LogHeader_RemovedStringWhether the log was removed by a reorg; true or false
Topics1
Topics_HashArrayIndexed topics of the log, as an array of hex strings; the first is the event signature hash
Transaction4
Transaction_FromStringAddress that signed the transaction, 0x-prefixed
Transaction_HashStringHash of the containing transaction, 0x-prefixed. The join key
Transaction_IndexUInt64Position of the transaction within the block
Transaction_ToStringAddress the transaction called, 0x-prefixed
TransactionStatus1
TransactionStatus_SuccessStringWhether the transaction succeeded; true or false
Sample file
transfers24 columnsOne row per native ETH or token transfer on Robinhood Chain, with sender, receiver, token metadata and a USD value where a price exists.
ColumnTypeDescription
Block3
Block_DateDateUTC date of the block
Block_NumberUInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Fee1
Fee_SenderFeeStringNetwork 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
Transaction3
Transaction_HashStringHash of the transaction this row settled in, 0x-prefixed; the join key to transactions and logs
Transaction_IndexUInt64Position of the transaction within the block
Transaction_TypeUInt32EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702; Arbitrum-stack system transactions use types above 100
TransactionStatus1
TransactionStatus_SuccessStringWhether the transaction succeeded; the string true or false. Failed transactions are kept
Transfer16
Transfer_AmountStringAmount 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_AmountInUSDFloat64Amount 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_DecimalsInt32Decimals of the transferred currency, as its contract reports them
Transfer_Currency_DelegatedToStringImplementation address for proxy tokens; the string 0x when there is none
Transfer_Currency_FungibleStringWhether the currency is fungible; the string true or false, and false for NFTs
Transfer_Currency_NameStringName reported by the contract; lookalike tokens copy real names
Transfer_Currency_NativeStringtrue for native ETH, false for tokens. Filter on this column to separate ETH movement from token movement
Transfer_Currency_ProtocolNameStringToken standard, for example erc20 or erc721; empty for native ETH
Transfer_Currency_SmartContractStringContract of the transferred token, 0x-prefixed; the string 0x for native ETH
Transfer_Currency_SymbolStringSymbol reported by the contract; repeats across tokens, so join on the contract address
Transfer_IdStringToken id for NFT transfers; the string 0 for fungible transfers
Transfer_IndexUInt32Position within the transaction. Several rows in one transaction can share it
Transfer_SenderStringSending address, 0x-prefixed
Transfer_ReceiverStringReceiving address, 0x-prefixed
Transfer_TypeStringtoken for token transfers, transaction for a plain ETH send, call for ETH moved by a contract in an internal call
Transfer_URIStringMetadata URI for NFT transfers; empty otherwise
Sample file
dex_trades53 columnsOne 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.
ColumnTypeDescription
Block3
Block_DateDateUTC date of the block
Block_NumberUInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Fee1
Fee_SenderFeeStringNetwork 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_Buy15
Trade_Buy_AmountStringAmount 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_AmountInUSDFloat64USD 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_BuyerStringAddress that received the bought currency, usually a router or the trader
Trade_Buy_Currency_DecimalsInt32Decimals of the bought token, as its contract reports them
Trade_Buy_Currency_FungibleStringWhether the bought token is fungible; true or false, and false for NFTs
Trade_Buy_Currency_HasURIStringWhether the bought token carries a metadata URI; true or false
Trade_Buy_Currency_NameStringName reported by the bought token's contract; lookalike tokens copy real names
Trade_Buy_Currency_ProtocolNameStringToken standard on the bought side, for example erc20 or erc1155; empty for native ETH
Trade_Buy_Currency_SmartContractStringContract of the bought token, 0x-prefixed; the string 0x for native ETH
Trade_Buy_Currency_SymbolStringSymbol reported by the bought token's contract; not unique, so join on the contract
Trade_Buy_IdsArrayToken ids bought, as strings; empty for fungible tokens
Trade_Buy_OrderIdStringOrder 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_PriceFloat64Price of the bought currency in units of the sold currency
Trade_Buy_PriceInUSDFloat64USD 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_SellerStringAddress that sent the bought currency, usually the pool
Trade_Dex10
Trade_Dex_DelegatedToStringImplementation the DEX contract delegates to, when it is a proxy; 0x otherwise
Trade_Dex_OwnerAddressStringFactory or owner the index records for the pool, 0x-prefixed; the string 0x when none. Use it to tell forks apart
Trade_Dex_Pair_DecimalsInt32Decimals of the pool's own LP token; 0 when the pool has none, as in v3 and v4
Trade_Dex_Pair_NameStringName of the pool's own LP token, for example Uniswap V2; empty for v3, v4 and other pools without one
Trade_Dex_Pair_SmartContractStringPool 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_SymbolStringSymbol of the pool's own LP token, for example UNI-V2; not unique
Trade_Dex_ProtocolFamilyStringProtocol family, for example Uniswap, Pons, PancakeSwapInfinity or Aerodrome. Filter this column to keep or drop a venue
Trade_Dex_ProtocolNameStringProtocol and version as indexed, for example uniswap_v3 or seaport_v1.4. It names the pool design, so forks can share it
Trade_Dex_ProtocolVersionStringProtocol version string
Trade_Dex_SmartContractStringContract 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
Trade4
Trade_FeesStringFees 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_IndexUInt32Position of the swap within the transaction
Trade_PriceAsymmetryFloat64Relative gap between the prices implied by the two sides of the swap; 0 when they agree
Trade_SenderStringAddress that called the pool, often a router or aggregator
Trade_Sell15
Trade_Sell_AmountStringAmount 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_AmountInUSDFloat64USD 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_BuyerStringAddress that received the sold currency, usually the pool
Trade_Sell_Currency_DecimalsInt32Decimals of the sold token, as its contract reports them
Trade_Sell_Currency_FungibleStringWhether the sold token is fungible; true or false, and false for NFTs
Trade_Sell_Currency_HasURIStringWhether the sold token carries a metadata URI; true or false
Trade_Sell_Currency_NameStringName reported by the sold token's contract; lookalike tokens copy real names
Trade_Sell_Currency_ProtocolNameStringToken standard on the sold side, for example erc20 or erc1155; empty for native ETH
Trade_Sell_Currency_SmartContractStringContract of the sold token, 0x-prefixed; the string 0x for native ETH
Trade_Sell_Currency_SymbolStringSymbol reported by the sold token's contract; not unique, so join on the contract
Trade_Sell_IdsArrayToken ids sold, as strings; empty for fungible tokens
Trade_Sell_OrderIdStringOrder 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_PriceFloat64Price of the sold currency in units of the bought currency
Trade_Sell_PriceInUSDFloat64USD 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_SellerStringAddress that sent the sold currency, usually a router or the trader
Transaction4
Transaction_FromStringAddress that signed the transaction: the trader behind any router
Transaction_HashStringHash of the transaction, 0x-prefixed; the join key to transfers and logs
Transaction_IndexUInt64Position of the transaction within the block
Transaction_ToStringContract the transaction called, often a router
TransactionStatus1
TransactionStatus_SuccessStringWhether the transaction succeeded; true or false
Sample file
miner_rewards54 columnsOne row per block, with the full block header and the sequencer's take split into static, dynamic, transaction-fee and burnt components.
ColumnTypeDescription
Other1
ChainIdUInt32EVM chain id; 4663 for Robinhood Chain mainnet
Block22
Block_DateDateUTC date of the block
Block_TimeDateTimeBlock timestamp, UTC
Block_HashStringBlock hash, 0x-prefixed
Block_NumberUInt64Block height
Block_ParentHashStringHash of the parent block, 0x-prefixed
Block_UncleHashStringRoot of the uncles list. Robinhood Chain produces no uncles, so this is the empty-list hash on every block
Block_RootStringState root after the block
Block_TxHashStringRoot of the transactions trie
Block_ReceiptHashStringRoot of the receipts trie
Block_MixDigestStringMix digest field, hex
Block_CoinbaseStringAddress credited as block producer, 0x-prefixed; on Robinhood Chain this is the sequencer address 0xa4b000000000000000000073657175656e636572 on every block
Block_BloomStringBloom filter over the block's logs, hex
Block_ExtraStringExtra-data field of the block header, as the sequencer wrote it; hex
Block_NonceUInt64Block nonce
Block_DifficultyStringDifficulty field as recorded; Robinhood Chain has no proof of work, so it is 1 on every block
Block_GasLimitUInt64Gas limit of the block
Block_GasUsedUInt64Total gas used by the block
Block_BaseFeeStringBase fee per gas of the containing block, in ETH, as a decimal string
Block_Result_GasUInt64Gas accounted for in the block's execution result
Block_Result_ErrorsStringErrors recorded while executing the block; empty when there were none
Block_TxCountUInt32Number of transactions in the block
Block_UnclesCountUInt32Number of uncles; always 0 on Robinhood Chain
Uncle_Block18
Uncle_Block_DateDateUTC date of the uncle block
Uncle_Block_TimeDateTimeTimestamp of the uncle block, UTC
Uncle_Block_HashStringHash of the uncle block, 0x-prefixed
Uncle_Block_NumberUInt64Block height of the uncle; always 0 on Robinhood Chain
Uncle_Block_ParentHashStringHash of the uncle block's parent
Uncle_Block_UncleHashStringHash of the uncle block's own uncle list
Uncle_Block_RootStringState trie root of the uncle block
Uncle_Block_TxHashStringTransactions trie root of the uncle block
Uncle_Block_ReceiptHashStringReceipts trie root of the uncle block
Uncle_Block_MixDigestStringProof-of-work mix digest of the uncle block
Uncle_Block_CoinbaseStringMiner address credited with the uncle reward
Uncle_Block_BloomStringLogs bloom filter of the uncle block, hex
Uncle_Block_ExtraStringExtra-data field of the uncle block header; empty on a chain without uncles
Uncle_Block_NonceUInt64Proof-of-work nonce of the uncle block
Uncle_Block_DifficultyStringMining difficulty of the uncle block, as a decimal string
Uncle_Block_GasLimitUInt64Gas limit of the uncle block
Uncle_Block_GasUsedUInt64Gas used by the uncle block
Uncle_Block_BaseFeeStringBase fee per gas of the uncle block in ETH, as a decimal string; 0 before EIP-1559
Uncle1
Uncle_IndexUInt32Index of the uncle; always 0 on Robinhood Chain
Reward12
Reward_TotalStringTotal reward credited for the block, as a decimal string
Reward_TotalInUSDFloat64Total reward in USD
Reward_StaticStringFixed block subsidy, as a decimal string; 0 on Robinhood Chain
Reward_StaticInUSDFloat64Static reward in USD
Reward_DynamicStringDynamic reward component, as a decimal string
Reward_DynamicInUSDFloat64Dynamic reward component in USD
Reward_TxFeesStringTransaction fees credited to the sequencer, as a decimal string
Reward_TxFeesInUSDFloat64Transaction fees in USD
Reward_BurntFeesStringETH burnt by the base fee across the block, as a decimal string
Reward_BurntFeesInUSDFloat64Burnt fees in USD at the block's hourly ETH price
Reward_UncleStringUncle reward, as a decimal string; always 0 on Robinhood Chain
Reward_UncleInUSDFloat64Uncle reward in USD; always 0 on Robinhood Chain
Sample file
balances11 columnsOne 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.
ColumnTypeDescription
Balance_AddressStringWallet or contract that holds the balance, lower case with 0x
Block_DateDateUTC date of the block
Currency_NameStringToken name reported by the contract; not unique
Currency_SmartContractStringToken contract, lower case with 0x; 0x for native ETH. The key for joins
Currency_SymbolStringToken symbol reported by the contract; repeats across tokens, so join on the contract
Currency_ProtocolNameStringToken standard, erc20 or erc721; empty for native ETH
Balance_AmountStringBalance held at the end of the file's block range, decimal adjusted, as a decimal string
Balance_FirstChangeTimeDateTimeFirst time this address held this token, UTC
Balance_LastChangeTimeDateTimeLast time this balance changed, UTC
Balance_UpdateCountUInt64Number of balance changes recorded for this address and token
Balance_RowCountUInt64Rows aggregated into this snapshot; always 1
Sample file

Ask an AI about this data

Send this dataset’s full schema to an assistant and ask it anything. It reads the plain-text brief first, so the answer comes from the real column list rather than a guess.

Start with

Opens a new chat with the question filled in. Nothing about you is sent to Bitquery, and the assistant sees only the public brief.

Delivery

Parquet files in a Requester Pays S3 bucket or a Cloudflare R2 bucket, chosen at checkout. On S3 you download with your own AWS account and AWS bills the transfer; on R2 you download with a read-only API key and pay no egress. Layout:

# blocks: 50 blocks per file, sorted ascending
robinhood/blocks<start_block>_<end_block>.parquet

# transactions: 50 blocks per file, sorted ascending
robinhood/transactions<start_block>_<end_block>.parquet

# calls: 50 blocks per file, sorted ascending
robinhood/calls<start_block>_<end_block>.parquet

# events: 50 blocks per file, sorted ascending
robinhood/events<start_block>_<end_block>.parquet

# transfers: 50 blocks per file, sorted ascending
robinhood/transfers<start_block>_<end_block>.parquet

# dex_trades: 50 blocks per file, sorted ascending
robinhood/dex_trades<start_block>_<end_block>.parquet

# miner_rewards: 50 blocks per file, sorted ascending
robinhood/miner_rewards<start_block>_<end_block>.parquet

# balances: 50 blocks per file, sorted ascending
robinhood/balances<start_block>_<end_block>.parquet
  1. Download a free sampleNo email needed.
  2. Pay nowName, work email and licence check.
  3. Pay the invoiceBy card or bank transfer.
  4. Download from S3 or R2The team prepares the export and emails the bucket path, plus a read-only API key for R2 orders.

Need new data after your purchase?

Kafka Streams sends new Robinhood Chain data in real time, so your copy can stay current after the files end. It is sold on an Enterprise plan.

Read the Kafka docs

Time windows

Every window includes all 8 tables and 290 columns. Only the time range changes.

30 days
Latest month
Sep 25, 2026 → Oct 25, 2026
$300
Pay now
178 days
Full history
Apr 30, 2026 → Oct 25, 2026
$3,000
Pay now
In every window
  • All 8 tables, 290 columns
  • Parquet files in the layout under Delivery
  • S3 or R2 download, chosen at checkout
  • Licensed under the Data License

FAQ

15 questions
What is included in the Robinhood Chain dataset?

Eight Parquet tables with 290 documented columns in total: blocks (22), transactions (40), calls (41), events (45), transfers (24), dex_trades (53), miner_rewards (54) 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.

How far back does the full history go?

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.

How large is the full dataset?

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.

How do the tables join?

On Transaction_Hash across transactions, calls, events, transfers and dex_trades, and on Block_Number to blocks and miner_rewards. 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.

What is the balances table exactly?

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.

What is deliberately not in this dataset?

Balance updates, the per-transaction balance changes, are not part of this bundle; balances is a snapshot instead. 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.

Which DEXes are in dex_trades?

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.

Does Robinhood Chain have uncles?

No. It is an Arbitrum-stack rollup with a single sequencer, so there are no uncle blocks: Block_UnclesCount is 0 and Block_UncleHash is the empty-list hash on every block, and Block_Difficulty is 1 throughout. They are kept so a query written against one EVM chain runs unchanged here.

How much of it is valued in USD?

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.

Are failed transactions included?

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.

How do I get one contract's activity?

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.

How are amounts and booleans encoded?

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.

How do I load it?

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.

How is the data delivered, and how current is it?

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.

Can I try before I buy?

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.