The whole Polygon chain as flat Parquet: blocks, transactions, internal calls, decoded events, transfers, DEX trades and validator rewards, all joined on the transaction hash.
Seven flat Parquet tables covering Polygon end to end at block resolution: blocks, transactions, calls, events, transfers, dex_trades and miner_rewards. Every table carries Block_Number, Block_Time and Transaction_Hash, so they join without a lookup table.
The calls and events tables are the ones an RPC node will not give you cheaply: every internal call frame with its decoded function signature, arguments, gas, revert state and state changes, and every log with its decoded topic signature and the call frame that emitted it.
Polygon renamed MATIC to POL, and the stored layout predates the rename: the S3 prefix is matic/, and native rows in transfers still carry the symbol MATIC. Filter on Transfer_Currency_Native rather than on the symbol.
Use cases
Full-chain analytics without running an archive node or paying per RPC call
Contract forensics on decoded internal calls, with gas, revert state and state changes
Token and stablecoin flow analysis across the whole chain, not one contract at a time
Validator economics: base fee burn, priority fees and block rewards per producer
7 tables
268 columns · free sample for each table
blocks
22 columns
One row per Polygon block, with the producer, gas, base fee and the trie roots.
matic/blocks<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Receipt_TypeUInt32Receipt type, mirroring the transaction type
Signature3
Signature_RStringR component of the ECDSA signature, hex
Signature_SStringS component of the ECDSA signature, hex
Signature_VStringV component of the ECDSA signature, hex
Transaction19
Transaction_CallCountUInt32Number of call frames the transaction produced, the top-level call included. Join to the calls table on Transaction_Hash to read them
Transaction_CostStringTotal cost of the transaction, value plus fee, as a decimal string
Transaction_CostInUSDFloat64Total cost in USD
Transaction_DataStringRaw calldata of the transaction, hex
Transaction_FromStringAddress that signed the transaction, 0x-prefixed
Transaction_GasUInt64Gas limit the sender set
Transaction_GasFeeCapStringEIP-1559 max fee per gas, as a decimal string
Transaction_GasPriceStringGas price the sender offered, as a decimal string
Transaction_GasPriceInUSDFloat64Offered gas price in USD
Transaction_GasTipCapStringEIP-1559 max priority fee per gas, as a decimal string
Transaction_HashStringTransaction hash, 0x-prefixed. The join key across every matic table
Transaction_IndexUInt64Position of the transaction within the block
Transaction_NonceUInt64Sender's nonce
Transaction_ProtectedStringWhether the signature is EIP-155 replay protected; true or false
Transaction_TimeDateTimeTimestamp of the transaction, UTC; equal to the block time
Transaction_ToStringAddress the transaction called; the string 0x for a contract deployment
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; 137 for Polygon 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 POL 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 POL. 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
transfers24 columnsOne row per native POL or token transfer on Polygon, 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 POL, 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
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 POL, false for tokens. Native rows still carry the old symbol MATIC; filter on this column to find them
Transfer_Currency_ProtocolNameStringToken standard, for example erc20 or erc721; empty for native POL
Transfer_Currency_SmartContractStringContract of the transferred token, 0x-prefixed; the string 0x for native POL
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_trades54 columnsOne row per DEX swap on Polygon, with both sides, pool and protocol, fees, transaction details 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 POL, 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 and Polymarket shares, 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 and Polymarket shares
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 POL
Trade_Buy_Currency_SmartContractStringContract of the bought token, 0x-prefixed; the string 0x for native POL
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 and Polymarket, 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_DelegatedStringtrue when the pool ran through a delegate call, as proxy and clone pools do, else false; the implementation address is not included
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, PancakeSwap, Balancer or Polymarket. Filter this column to exclude Polymarket order fills
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
Trade5
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_PoolIdString32-byte pool id, 0x-prefixed, for Uniswap v4 and PancakeSwap Infinity, whose pools share one contract; empty for other protocols
Trade_SenderStringAddress that called the pool, often a router or aggregator
Trade_SuccessStringWhether this swap succeeded; true or false. A swap can fail inside a successful transaction, so filter on this column
Trade_Sell15
Trade_Sell_AmountStringAmount sold, decimal adjusted, as a decimal string with exactly as many places as the token has decimals; for NFTs and Polymarket shares, 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 and Polymarket shares
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 POL
Trade_Sell_Currency_SmartContractStringContract of the sold token, 0x-prefixed; the string 0x for native POL
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 and Polymarket, 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
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.
Seven Parquet tables with 269 documented columns in total: blocks (22), transactions (55), calls (42), events (45), transfers (24), dex_trades (54) and miner_rewards (27). Covering the most recent month to yesterday, refreshed daily.
How do the tables join?
On Transaction_Hash, which appears in every table except blocks and miner_rewards; those two 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. A log points back to the frame that emitted it through Call_Index.
What is deliberately not in this dataset?
Two things. The Polymarket prediction tables — prediction trades, prediction settlements and prediction managements — are not here; they are sold as the separate Polymarket dataset. Balance updates are also excluded. If you need either, ask and we will quote them alongside this one.
So is Polymarket activity in the DEX trades table or not?
The dedicated Polymarket tables are not, and neither is the matic/dex_trades/polymarket prefix. But dex_trades is a decode of all swap activity on Polygon, and Polymarket order fills are on-chain swaps on Polygon, so rows whose Trade_Dex_ProtocolFamily is Polymarket do appear in it. Filter that column out if you want Polymarket excluded entirely — it is a large share of recent Polygon swap volume, so the difference is not marginal.
Why is the S3 prefix matic and not polygon?
The layout was set before the MATIC to POL rebrand and we did not move it, because moving it would break every existing manifest and download script. Paths are matic/blocks, matic/transactions and so on. Nothing about the data is stale — only the prefix name.
Does Polygon have uncles? The schema has uncle columns.
No. Polygon's Bor consensus produces no uncle blocks, so Block_UnclesCount is 0 on every block, Block_UncleHash is the empty-list hash, and Reward_Uncle, Uncle_Block_Number and Uncle_Index in miner_rewards are empty or zero throughout. The columns exist because the schema is shared with chains that do have uncles; they are kept rather than dropped so a query written against one EVM chain runs unchanged here.
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 much of it is valued in USD?
Less than you might expect, and the dataset says so rather than filling the gap. Only six currencies have an hourly price series on Polygon — POL, WPOL, WETH, USDT, DAI and the bridged USDC.e — which prices roughly a fifth of transfer rows; the rest is mostly airdrop and spam tokens. DEX trades do much better, because each swap is priced from its safer side and most swaps have a stablecoin or POL on one of them. A USD value of 0 means either a zero-value row or no price; the column cannot tell the two apart.
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, and dex_trades additionally carries Trade_Success, because a single swap can fail inside a transaction that succeeded. 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 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. Signed HTTPS links are emailed once the files are prepared, or on request we deliver 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. Every 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.