Tokenized stocks on Robinhood Chain come from two issuers, and copies under the same tickers are common. We keep only the real ones: tokens deployed by the Robinhood stock-token factory (0x4783c67b63de2b358ac5951a7d41f47a38f3c046), named "<company> • Robinhood Token", and Ondo Global Markets tokens, the "…on" tickers minted to Ondo's issuance wallet (0xf2dc25b8a5231667d8cf0ecd476fb46805186572). That is about 195 Robinhood and 401 Ondo tokens on 15 October 2026. New listings from either issuer are picked up by the same rules. Each table keeps the standard Robinhood Chain schema, with nothing renamed or added.
Three tables. transfers has every token transfer of a stock token; dex_trades has every DEX trade with a stock token on either side; mint_burn has the transfers from or to the zero address, which are issuance and redemption. Filter on Transfer_Currency_SmartContract or the trade's currency contracts, never on the symbol: NVDA, GME and others are reused by unrelated tokens.
Use cases
Holder and flow analysis for one stock token, such as NVDA or TSLA
Issuance and redemption volume per stock, from mints and burns
On-chain price against the listed share price, from DEX trades
Comparing the Robinhood and Ondo versions of the same stock
3 tables
101 columns · free sample for each table
transfers
24 columns
One row per transfer of a Robinhood or Ondo stock token, in the standard Robinhood Chain transfers schema.
transfers24 columnsOne row per transfer of a Robinhood or Ondo stock token, in the standard Robinhood Chain transfers schema.
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
dex_trades53 columnsOne row per DEX trade with a Robinhood or Ondo stock token on either side, in the standard Robinhood Chain dex_trades schema.
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
mint_burn24 columnsIssuance and redemption: transfers of a stock token from or to the zero address, in the transfers schema.
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
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.
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:
What is in the Robinhood Tokenized Stocks dataset?
Three Parquet tables in the standard Robinhood Chain schema: transfers (24 columns), dex_trades (53 columns) and mint_burn (24 columns, the transfers table limited to mints and burns). They cover the stock tokens of Robinhood and Ondo Global Markets from June 2026.
Which issuers and tokens are included?
Robinhood: the ERC-20s deployed by its stock-token factory, about 195 on 15 October 2026, less one test token (PEACH_DEFI_1). Ondo Global Markets: the 401 tokens with an "on" suffix minted to Ondo's issuance wallet. Tokens copying their names from other deployers are left out.
How big is it?
Roughly 230 million transfers, 90 million DEX trades and 190,000 mints and burns from June to mid-October 2026, about 50 GB of ZSTD Parquet, estimated from sampled days. A recent month is about 10 to 13 GB. Activity varies a lot: on sampled days transfers ran from 0.7 million (12 October) to 6.3 million (1 September 2026).
How do I find the mints and burns for one stock?
Use the mint_burn table and filter Transfer_Currency_SmartContract on the token. A row with Transfer_Sender 0x0000000000000000000000000000000000000000 is a mint; one with that address as Transfer_Receiver is a burn.
Are USD values included?
The USD columns are present but read 0 for stock tokens and stablecoins for now, because our Robinhood Chain price feed covers only ETH. Amounts and token prices in the quote token are exact; use DEX trades against USDG for a USD price.
How were the tables checked?
We matched the queries against our GraphQL API on 12 October 2026: 190,611 NVDA transfers, 79 NVDA mints and 117,259 NVDA DEX trades, the same counts on both. A trades row from the published Robinhood Chain sample (NVDA against USDG, 7 September 2026) came out with identical amounts and prices.
What should I watch for?
Symbols are not unique, so filter by contract address. Transfer_Index and Trade_Index restart inside each call, so the same index can repeat within one transaction. Trade_Fees carries the fees our source records; pool swap fees are not always in it.
How do I load it?
With DuckDB: SELECT Transfer_Currency_Symbol, count(*) FROM read_parquet('transfers/*.parquet') GROUP BY 1 ORDER BY 2 DESC. pandas, Polars, Spark and ClickHouse read the same files.
How is the data delivered?
As flat Parquet files under a stable layout, one prefix per table, with a JSON manifest listing each 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.
Can I try before I buy?
Yes. Each table links to a public sample file from 12 October 2026: 356 transfers and 214 DEX trades from blocks 86,730,700 to 86,730,799, and 6 mints and burns from blocks 86,728,200 to 86,728,299. No email address required.