TRON since June 2018 as flat Parquet: blocks, transactions with energy and bandwidth receipts, internal calls, decoded events, TRX and TRC-20 transfers and DEX trades, at block resolution.
Six flat Parquet tables covering TRON from 25 June 2018 to yesterday, at block resolution: blocks, transactions, calls, events, transfers and dex_trades. Every table carries Block_Number and Block_Time, and every table but blocks carries Transaction_Hash, so they join without a lookup table.
TRON is not an EVM clone, and the schema says so. Transactions carry the resource receipt the chain records, energy used, energy burnt, bandwidth used and the TRX fee for each, plus the sender's fee limit and the protobuf contract type. Calls and events are decoded the same way as on our EVM chains, so a query written for Ethereum events runs here once the address format is changed.
Addresses are base58 strings starting with T, amounts are decimal strings adjusted from SUN, and native rows in transfers carry the symbol TRX. Filter on Transfer_Currency_Native rather than on the symbol.
Use cases
Full-chain analytics without running a TRON full node or paying per API call
USDT flow analysis across all addresses, with the transaction and fee context around each transfer
Energy and bandwidth cost research from per-transaction receipts
Contract forensics on decoded internal calls and events for any TRC-20 or DEX contract
6 tables
251 columns · free sample for each table
blocks
13 columns
One row per TRON block, with the producing super representative, transaction count and trie roots.
tron/blocks<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
transactions36 columnsOne row per TRON transaction, with the energy and bandwidth receipt, fee limit, result and contract call counts.
ColumnTypeDescription
Block3
Block_NumberInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Block_DateDateUTC date of the block
Witness3
Witness_AddressStringAddress of the block producer
Witness_IdInt64Numeric id of the super representative that produced the block
Witness_SignatureStringSignature of the block producer
Transaction12
Transaction_DataStringRaw calldata of the transaction, hex
Transaction_ExpirationDateTimeTime after which the transaction can no longer be included, UTC
Transaction_FeeStringTransaction fee in TRX, decimal adjusted from SUN, as a decimal string
Transaction_FeeInUSDFloat64Transaction fee valued in USD at the hourly TRX price for the block's hour
Transaction_FeeLimitStringMaximum TRX the sender allowed the transaction to burn for energy, decimal adjusted from SUN, as a decimal string
Transaction_FeeLimitInUSDFloat64Fee limit valued in USD at the hourly TRX price for the block's hour
Transaction_FeePayerStringAddress that paid the fee, which is the transaction sender
Transaction_IndexInt32Position of the transaction within the block
Transaction_HashStringHash of the transaction this row settled in; the join key across the tables
Transaction_SignaturesStringSignatures on the transaction, JSON array of hex strings
Transaction_TimeDateTimeTimestamp of the transaction, UTC; equal to the block time
Transaction_TimestampDateTimeTimestamp the sender put in the transaction, UTC; differs from Block_Time
Transaction_Result3
Transaction_Result_MessageStringError message returned by the contract when the transaction failed; empty on success
Transaction_Result_StatusStringTransaction outcome as the chain spells it: SUCESS (sic, the chain's own spelling) or FAILED
Transaction_Result_SuccessStringWhether the transaction succeeded; the string true or false
Transaction_Receipt8
Transaction_Receipt_EnergyFeeInt64TRX burnt for energy, in SUN
Transaction_Receipt_EnergyPenaltyTotalInt64Extra energy charged for calling a popular contract, in energy units
Transaction_Receipt_EnergyUsageTotalInt64Total energy consumed, including what the contract owner's stake covered
Transaction_Receipt_NetFeeStringTRX burnt for bandwidth, decimal adjusted from SUN, as a decimal string
Transaction_Receipt_NetFeeInUSDFloat64Bandwidth fee valued in USD at the hourly TRX price for the block's hour
Transaction_Receipt_NetUsageInt64Bandwidth consumed, in bytes
Transaction_Receipt_OriginEnergyUsageInt64Energy paid from the contract owner's own stake
Transaction_Receipt_ResultStringReceipt result code: DEFAULT for plain transfers and resource operations, SUCCESS or the failure reason such as OUT_OF_ENERGY for contract calls
Contract7
Contract_AddressStringContract the transaction called
Contract_ArgumentsCountUInt32Number of decoded arguments on the contract call
Contract_ExecutionResultsCountUInt32Number of execution results recorded for the contract call
Contract_LogsCountUInt32Logs emitted by the contract call
Contract_InternalTransactionsCountUInt32Internal transactions triggered by the contract call
Contract_TypeStringTRON contract type, for example TriggerSmartContract or TransferContract
Contract_TypeUrlStringProtobuf type of the contract call, for example type.googleapis.com/protocol.TriggerSmartContract
dex_trades68 columnsOne row per DEX swap on TRON, with both sides, pool and protocol, fees, transaction details and a USD value where a price exists.
ColumnTypeDescription
Block3
Block_NumberInt64Block height
Block_DateDateUTC date of the block
Block_TimeDateTimeBlock timestamp, UTC
Trade_Buy16
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_AssetIdStringTRC-10 asset id of the bought token; empty for TRX and TRC-20 tokens
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_ProtocolNameStringToken standard on the bought side, for example erc20 or erc1155; empty for native TRX
Trade_Buy_Currency_SmartContractStringContract of the bought token, base58; empty for native TRX
Trade_Buy_Currency_SymbolStringSymbol reported by the bought token's contract; not unique, so join on the contract
Trade_Buy_Currency_NameStringName reported by the bought token's contract; lookalike tokens copy real names
Trade_Buy_Currency_HasURIStringWhether the bought token carries a metadata URI; true or false
Trade_Buy_Currency_DelegatedToStringImplementation the bought token's contract delegates to, when it is a proxy; empty otherwise
Trade_Buy_URIsStringToken URIs of the bought asset, as a JSON array; empty for fungible tokens
Trade_Buy_SellerStringAddress that sent the bought currency, usually the pool
Trade_Buy_OrderIdStringOrder id for order-book and marketplace trades on order-book venues, hex without 0x; empty for pool swaps. The same value on both sides
Trade_Buy_IdsStringToken ids bought, as strings; empty for fungible tokens
Trade7
Trade_PriceInUSDFloat64Price of one unit of the bought token in USD at the hourly price for the block's hour; 0 when no price
Trade_PriceFloat64Price of the trade as the DEX reports it, sold amount per unit bought
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_SuccessStringWhether this swap succeeded; true or false. A swap can fail inside a successful transaction, so filter on this column
Trade_SenderStringAddress that called the pool, often a router or aggregator
Trade_PriceAsymmetryFloat64Relative gap between the prices implied by the two sides of the swap; 0 when they agree
Trade_Dex16
Trade_Dex_DelegatedToStringImplementation the DEX contract delegates to, when it is a proxy; empty otherwise
Trade_Dex_FeeRecipientStringAddress that received the DEX fee for the swap, when the protocol reports one; empty otherwise
Trade_Dex_OwnerAddressStringFactory or owner the index records for the pool, base58; empty when none. Use it to tell forks apart
Trade_Dex_Pair_SmartContractStringPool token contract for v2-style pools, base58; empty 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_Pair_AssetIdStringTRC-10 asset id of the pool's own LP token; empty when the pool has none
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_DelegatedStringWhether the pool contract is a proxy; the string true or false
Trade_Dex_Pair_FungibleStringWhether the pool's LP token is fungible; the string true or false
Trade_Dex_Pair_HasURIStringWhether the pool's LP token has a token URI; the string true or false
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_ProtocolNameStringToken standard of the pool's LP token, for example trc20; empty when the pool has none
Trade_Dex_ProtocolFamilyStringProtocol family, for example SunSwap. Filter this column to keep or drop a venue
Trade_Dex_ProtocolNameStringProtocol and version as indexed, for example sunswap_v2. It names the pool design, so forks can share it
Trade_Dex_ProtocolVersionStringProtocol version string
Trade_Dex_SmartContractStringContract that emitted the swap, base58; the pool contract for SunSwap pools
Trade_Sell16
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_AssetIdStringTRC-10 asset id of the sold token; empty for TRX and TRC-20 tokens
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_ProtocolNameStringToken standard on the sold side, for example erc20 or erc1155; empty for native TRX
Trade_Sell_Currency_SmartContractStringContract of the sold token, base58; empty for native TRX
Trade_Sell_Currency_SymbolStringSymbol reported by the sold token's contract; not unique, so join on the contract
Trade_Sell_Currency_NameStringName reported by the sold token's contract; lookalike tokens copy real names
Trade_Sell_Currency_HasURIStringWhether the sold token carries a metadata URI; true or false
Trade_Sell_Currency_DelegatedToStringImplementation the sold token's contract delegates to, when it is a proxy; empty otherwise
Trade_Sell_URIsStringToken URIs of the sold asset, as a JSON array; empty for fungible tokens
Trade_Sell_SellerStringAddress that sent the sold currency, usually a router or the trader
Trade_Sell_OrderIdStringOrder id for order-book and marketplace trades on order-book venues, hex without 0x; empty for pool swaps. The same value on both sides
Trade_Sell_IdsStringToken ids sold, as strings; empty for fungible tokens
Transaction3
Transaction_HashStringHash of the transaction this row settled in; the join key across the tables
Transaction_IndexInt32Position of the transaction within the block
Transaction_FeeStringTransaction fee in TRX, decimal adjusted from SUN, as a decimal string
TransactionStatus1
TransactionStatus_SuccessStringWhether the transaction succeeded; the string true or false
Call2
Call_Signature_SignatureStringFull function signature
Call_Signature_SignatureHashStringFour-byte selector, hex without a 0x prefix
Log2
Log_Signature_SignatureStringFull event signature
Log_Signature_SignatureHashStringEvent topic0, hex without a 0x prefix
Contract2
Contract_AddressStringContract the transaction called
Contract_TypeStringTRON contract type, for example TriggerSmartContract or TransferContract
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:
# blocks: 50 blocks per file, sorted ascending
tron/blocks<start_block>_<end_block>.parquet# transactions: 50 blocks per file, sorted ascending
tron/transactions<start_block>_<end_block>.parquet# calls: 50 blocks per file, sorted ascending
tron/calls<start_block>_<end_block>.parquet# events: 50 blocks per file, sorted ascending
tron/events<start_block>_<end_block>.parquet# transfers: 50 blocks per file, sorted ascending
tron/transfers<start_block>_<end_block>.parquet# dex_trades: 50 blocks per file, sorted ascending
tron/dex_trades<start_block>_<end_block>.parquet
Download a free sampleNo email needed.
Pay nowName, work email and licence check.
Pay the invoiceBy card or bank transfer.
Download from S3 or R2The team prepares the export and emails the bucket path, plus a read-only API key for R2 orders.
Time windows
Every window includes all 6 tables and 251 columns. Only the time range changes.
Six Parquet tables with 251 documented columns in total: blocks (13), transactions (36), calls (46), events (45), transfers (43) and dex_trades (68). Each purchase covers the window you choose, through to yesterday, refreshed daily. The Full tier starts at the start of indexed history on 25 June 2018.
How far back does the full history go, and why buy it?
To 25 June 2018, the start of indexed history; the first transfer sits at block 342. TRON's shape has changed since: USDT moved from Omni onto TRC-20 in 2019, and stablecoin volume has grown until it dominates the chain. A baseline before those shifts, a long backtest, or a contract's deployment-to-present history needs the full archive rather than a recent slice.
How large is the full dataset?
Transfers alone is about 13 billion rows, estimated from the live table for the TRON Transfers product. We size the other tables before delivery and send you the exact figures with the manifest, so you can plan storage before downloading. If calls and events are more than you need, we can quote the other four tables on their own.
How do the tables join?
On Transaction_Hash, which appears in every table except blocks; blocks join on Block_Number. 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.
What is deliberately not in this dataset?
Balance updates. The chain-wide balance_updates_address table exists in our store but is not part of this bundle, because it carries several rows per transfer and would dominate the size. If you need it, ask and we will quote it alongside this one.
How are fees recorded?
The way TRON charges them. A transaction consumes bandwidth and, for contract calls, energy; what the sender's staked resources do not cover is burnt as TRX. Transaction_Receipt_EnergyUsageTotal and Transaction_Receipt_NetUsage are the resources used, Transaction_Receipt_EnergyFee and Transaction_Receipt_NetFee are the TRX actually burnt, and Transaction_Fee is their sum. Transaction_FeeLimit is the ceiling the sender set. In the sample window most transactions burnt nothing, because staked resources covered them.
What do the result columns mean?
Transaction_Result_Status is the chain's own outcome, spelt SUCESS or FAILED as the chain spells it. Transaction_Receipt_Result is the receipt code: DEFAULT for plain transfers and resource operations, SUCCESS or a failure reason such as OUT_OF_ENERGY for contract calls. Contract_Type and Contract_TypeUrl say what kind of operation the transaction was: TransferContract, TriggerSmartContract, DelegateResourceContract and so on.
Which DEXes are in dex_trades?
Every venue we decode on TRON, identified by Trade_Dex_ProtocolFamily and Trade_Dex_ProtocolName on each row. In the sample window the only family present was SunSwap, which carries most TRON swap volume. Filter the family column to keep or drop a venue.
How much of it is valued in USD?
TRX and TRC-20 tokens with an hourly price series are valued; TRC-10 tokens and unpriced tokens carry 0. A USD value of 0 therefore means either a zero-value row or no price, and the column cannot tell the two apart. USDT is priced throughout, and it is the bulk of TRON transfer value.
Are failed transactions included?
Yes, throughout, and the export applies no filter of its own. Transaction_Result_Status and Transaction_Receipt_Result carry the chain's own result codes on every transaction, and dex_trades additionally carries Trade_Success. 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, or USDT only?
Filter Call_To in calls and Log_SmartContract in events to the contract, in base58. For token flow, filter Transfer_Currency_SmartContract in transfers; USDT is TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t. Join on contract addresses rather than symbols, which repeat.
How are amounts and booleans encoded?
Amounts are decimal-adjusted decimal strings, carrying exactly as many places as the token has decimals; TRX amounts are adjusted from SUN, where one TRX is a million SUN, except the energy fee, which the chain reports in SUN. 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.
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.