# Robinhood Tokenized Stocks | Bitquery Data Store

Transfers, DEX trades and mints of Robinhood and Ondo stock tokens on Robinhood Chain since June 2026, one row per transfer or trade.

Dataset page: https://bitquery.io/datastore/datasets/robinhood-tokenized-stocks
Network: Robinhood Chain
Category: RWA, Transfers, Trades
Tables: 3
Columns: 101
Coverage: 2026-06-05 to 2026-10-14
Rows: about 320M
Size: about 50 GB
Format: Apache Parquet, ZSTD compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

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.

## What people use it for

- 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

## Tables (3)

### transfers: 24 columns

One row per transfer of a Robinhood or Ondo stock token, in the standard Robinhood Chain transfers schema.

Bucket prefix: robinhood/tokenized_stocks_transfers
File naming: <start_block>_<end_block>.parquet
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/tokenized_stocks_transfers/86730700_86730799.parquet
Sample updated: Oct 15, 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 trade with a Robinhood or Ondo stock token on either side, in the standard Robinhood Chain dex_trades schema.

Bucket prefix: robinhood/tokenized_stocks_dex_trades
File naming: <start_block>_<end_block>.parquet
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/tokenized_stocks_dex_trades/86730700_86730799.parquet
Sample updated: Oct 15, 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 |

### mint_burn: 24 columns

Issuance and redemption: transfers of a stock token from or to the zero address, in the transfers schema.

Bucket prefix: robinhood/tokenized_stocks_mint_burn
File naming: <start_block>_<end_block>.parquet
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/robinhood/tokenized_stocks_mint_burn/86728200_86728299.parquet
Sample updated: Oct 15, 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 |

## Price

- Latest month (Sep 14, 2026 → Oct 14, 2026): $300 one-time, USD
- Last 12 months (Oct 14, 2025 → Oct 14, 2026): $3,000 one-time, USD

Every window includes all 3 tables and 101 columns. Only the time range changes.

## Questions buyers ask

Q: What is in the Robinhood Tokenized Stocks dataset?
A: 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.

Q: Which issuers and tokens are included?
A: 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.

Q: How big is it?
A: 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).

Q: How do I find the mints and burns for one stock?
A: 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.

Q: Are USD values included?
A: 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.

Q: How were the tables checked?
A: 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.

Q: What should I watch for?
A: 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.

Q: How do I load it?
A: 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.

Q: How is the data delivered?
A: 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.

Q: Can I try before I buy?
A: 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.

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