# Polygon | Bitquery Data Store

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.

Dataset page: https://bitquery.io/datastore/datasets/polygon
Network: Polygon
Category: Transactions, Transfers, Trades, Blocks
Tables: 7
Columns: 268
Coverage: first block to 2026-09-27
Format: Apache Parquet, ZSTD compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

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.

## What people use it for

- 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

## Tables (7)

### blocks: 22 columns

One row per Polygon block, with the producer, gas, base fee and the trie roots.

S3 prefix: matic/blocks
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/blocks/82133800_82133849.parquet

| column | type | description |
| --- | --- | --- |
| Block_BaseFee | String | EIP-1559 base fee per gas, in POL, as a decimal string |
| Block_BaseFeeInUSD | Float64 | Base fee per gas valued in USD at the block's hourly POL price; 0 when unpriced |
| Block_Bloom | String | Bloom filter over the block's logs, hex |
| Block_Coinbase | String | Address credited as block producer, 0x-prefixed; on Polygon this is the Bor validator |
| Block_Date | Date | UTC date of the block |
| Block_Difficulty | String | Difficulty field as recorded. Bor does not use proof of work, so read it as a consensus counter, not mining difficulty |
| Block_GasLimit | UInt64 | Gas limit of the block |
| Block_GasUsed | UInt64 | Total gas used by the block's transactions |
| Block_Hash | String | Block hash, 0x-prefixed |
| Block_MixDigest | String | Mix digest field, hex |
| Block_Number | UInt64 | Block height |
| Block_Nonce | UInt64 | Block nonce |
| Block_ParentHash | String | Hash of the parent block, 0x-prefixed |
| Block_ReceiptHash | String | Root of the receipts trie |
| Block_Result_Errors | String | Errors recorded while executing the block; empty when there were none |
| Block_Result_Gas | UInt64 | Gas accounted for in the block's execution result |
| Block_Root | String | State root after the block |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_TxCount | UInt32 | Number of transactions in the block |
| Block_TxHash | String | Root of the transactions trie |
| Block_UncleHash | String | Root of the uncles list. Polygon produces no uncles, so this is the empty-list hash on every block |
| Block_UnclesCount | UInt32 | Number of uncles; always 0 on Polygon |

### transactions: 55 columns

One row per Polygon transaction, with the full fee breakdown, receipt, signature and contract-code details.

S3 prefix: matic/transactions
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/transactions/82133800_82133849.parquet

| column | type | description |
| --- | --- | --- |
| Block_BaseFee | String | Base fee per gas of the containing block, in POL, as a decimal string |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Fee_Burnt | String | POL burnt by the base fee, as a decimal string |
| Fee_BurntInUSD | Float64 | Burnt fee in USD at the block's hourly POL price |
| Fee_EffectiveGasPrice | String | Gas price actually charged, in POL, as a decimal string |
| Fee_EffectiveGasPriceInUSD | Float64 | Effective gas price in USD |
| Fee_GasRefund | UInt64 | Gas refunded to the sender, in gas units |
| Fee_MinerReward | String | Portion of the fee paid to the validator, as a decimal string |
| Fee_MinerRewardInUSD | Float64 | Validator's share of the fee in USD |
| Fee_PriorityFeePerGas | String | Priority fee per gas, in POL, as a decimal string |
| Fee_PriorityFeePerGasInUSD | Float64 | Priority fee per gas in USD |
| Fee_Savings | String | Difference between the fee cap the sender authorised and what was charged |
| Fee_SavingsInUSD | Float64 | That saving in USD |
| Fee_SenderFee | String | Total network fee the sender paid for the transaction, in POL, as a decimal string |
| Fee_SenderFeeInUSD | Float64 | Total sender fee in USD |
| Receipt_Bloom | String | Bloom filter over the transaction's logs, hex |
| Receipt_ContractAddress | String | Address of the contract deployed by this transaction; the string 0x when none |
| Receipt_ContractAddressCode_Hash | String | Code hash of the deployed contract |
| Receipt_ContractAddressCode_Size | Int32 | Bytecode size of the deployed contract, in bytes |
| Receipt_ContractAddressCode_Suicided | String | Whether the deployed contract has self-destructed; true or false |
| Receipt_CumulativeGasUsed | UInt64 | Cumulative gas used in the block up to and including this transaction |
| Receipt_GasUsed | UInt64 | Gas used by this transaction alone |
| Receipt_PostState | String | Post-state root, for pre-Byzantium style receipts; usually empty |
| Receipt_Status | UInt64 | Receipt status: 1 succeeded, 0 failed |
| Receipt_Type | UInt32 | Receipt type, mirroring the transaction type |
| Signature_R | String | R component of the ECDSA signature, hex |
| Signature_S | String | S component of the ECDSA signature, hex |
| Signature_V | String | V component of the ECDSA signature, hex |
| Transaction_CallCount | UInt32 | Number of call frames the transaction produced, the top-level call included. Join to the calls table on Transaction_Hash to read them |
| Transaction_Cost | String | Total cost of the transaction, value plus fee, as a decimal string |
| Transaction_CostInUSD | Float64 | Total cost in USD |
| Transaction_Data | String | Raw calldata of the transaction, hex |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Transaction_Gas | UInt64 | Gas limit the sender set |
| Transaction_GasFeeCap | String | EIP-1559 max fee per gas, as a decimal string |
| Transaction_GasPrice | String | Gas price the sender offered, as a decimal string |
| Transaction_GasPriceInUSD | Float64 | Offered gas price in USD |
| Transaction_GasTipCap | String | EIP-1559 max priority fee per gas, as a decimal string |
| Transaction_Hash | String | Transaction hash, 0x-prefixed. The join key across every matic table |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| Transaction_Nonce | UInt64 | Sender's nonce |
| Transaction_Protected | String | Whether the signature is EIP-155 replay protected; true or false |
| Transaction_Time | DateTime | Timestamp of the transaction, UTC; equal to the block time |
| Transaction_To | String | Address the transaction called; the string 0x for a contract deployment |
| Transaction_ToCode_Hash | String | Code hash of the called address; empty when it is an externally owned account |
| Transaction_ToCode_Size | Int32 | Bytecode size of the called address, in bytes; 0 for an externally owned account |
| Transaction_ToCode_Suicided | String | Whether the called contract has self-destructed; true or false |
| Transaction_Type | UInt32 | EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702 |
| Transaction_Value | String | Native POL sent with the transaction, decimal adjusted, as a decimal string |
| Transaction_ValueInUSD | Float64 | That value in USD at the block's hourly POL price |
| TransactionStatus_EndError | String | Error the transaction ended with; empty when it succeeded |
| TransactionStatus_FaultError | String | Fault-level error raised during execution; empty when none |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |

### calls: 41 columns

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

S3 prefix: matic/calls
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/calls/82133800_82133849.parquet

| column | type | description |
| --- | --- | --- |
| Arguments | String | Decoded call arguments as a JSON array, when the signature resolved; empty otherwise |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Call_CallPath | Array | Path of call indexes from the transaction root down to this frame, as an array of integers |
| Call_CallerIndex | Int32 | Call_Index of the calling frame; -1 for the top-level call |
| Call_Create | String | Whether this frame deployed a contract; true or false |
| Call_Delegated | String | Whether the frame ran through delegatecall, as proxies do; true or false |
| Call_Depth | UInt32 | Nesting depth, 0 for the top-level call |
| Call_EnterIndex | UInt32 | Order in which the frame was entered within the transaction |
| Call_Error | String | Error the call returned; empty on success |
| Call_ExitIndex | UInt32 | Order in which the frame was exited |
| Call_From | String | Calling address, 0x-prefixed |
| Call_Gas | UInt64 | Gas supplied to the call |
| Call_GasUsed | UInt64 | Gas consumed by this call and everything beneath it |
| Call_Index | UInt32 | Position of the frame within the transaction. Events reference it to name the frame that emitted a log |
| Call_Input | String | Raw calldata passed to the frame, hex |
| Call_InternalCalls | UInt32 | Number of calls made beneath this frame |
| Call_LogCount | UInt32 | Number of logs this frame emitted |
| Call_Opcode_Code | UInt32 | Numeric opcode that produced the frame |
| Call_Opcode_Name | String | Opcode name, for example CALL, DELEGATECALL, STATICCALL, CREATE or CREATE2 |
| Call_Output | String | Raw return data, hex |
| Call_Reverted | String | Whether the frame reverted; true or false. A frame can revert inside a transaction that succeeded |
| Call_SelfDestruct | String | Whether the called contract self-destructed; true or false |
| Call_Signature_Abi | String | ABI fragment for the resolved function; empty when the selector is unknown |
| Call_Signature_Name | String | Function name, when resolved |
| Call_Signature_Parsed | String | Human-readable form of the call: function name with argument values filled in |
| Call_Signature_Signature | String | Canonical function signature, for example transfer(address,uint256) |
| Call_Signature_SignatureHash | String | Four-byte function selector, hex |
| Call_Signature_SignatureType | String | How the signature was resolved, for example from a verified ABI or a public selector registry |
| Call_Success | String | Whether the frame succeeded; true or false |
| Call_To | String | Called address, 0x-prefixed |
| Call_Value | String | Native POL sent with the call, decimal adjusted, as a decimal string |
| Call_ValueInUSD | Float64 | That value in USD at the block's hourly POL price; 0 when the value is 0 |
| Returns | String | Decoded return values as JSON, when the signature resolved; empty otherwise |
| StateChanges | String | Storage and balance changes the frame produced, as JSON |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| TransactionStatus_EndError | String | Error the parent transaction ended with; empty when it succeeded |
| TransactionStatus_FaultError | String | Fault-level error on the parent transaction; empty when none |
| TransactionStatus_Success | String | Whether the parent transaction succeeded; true or false |

### events: 45 columns

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

S3 prefix: matic/events
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/events/82824000_82824049.parquet

| column | type | description |
| --- | --- | --- |
| Arguments | String | Decoded event arguments as a JSON array, when the signature resolved; empty otherwise |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Call_CallPath | Array | Path of call indexes from the transaction root down to the emitting frame |
| Call_CallerIndex | Int32 | Call_Index of the frame that called the emitting frame; -1 at the top level |
| Call_Create | String | Whether the emitting frame deployed a contract; true or false |
| Call_Error | String | Error the emitting frame returned; empty on success |
| Call_From | String | Caller of the emitting frame, 0x-prefixed |
| Call_Gas | UInt64 | Gas supplied to the emitting frame |
| Call_GasUsed | UInt64 | Gas consumed by the emitting frame and everything beneath it |
| Call_Index | UInt32 | Position of the emitting frame within the transaction; join to calls on this plus Transaction_Hash |
| Call_InternalCalls | UInt32 | Number of calls made beneath the emitting frame |
| Call_Reverted | String | Whether the emitting frame reverted; true or false |
| Call_SelfDestruct | String | Whether the emitting contract self-destructed; true or false |
| Call_Signature_Abi | String | ABI fragment of the function the emitting frame ran |
| Call_Signature_Name | String | Name of that function, when resolved |
| Call_Signature_Signature | String | Canonical signature of that function |
| Call_Signature_SignatureHash | String | Four-byte selector of that function, hex |
| Call_Signature_SignatureType | String | How that function signature was resolved |
| Call_To | String | Address the emitting frame called, 0x-prefixed |
| Call_Value | String | Native POL sent with the emitting frame, decimal adjusted |
| ChainId | UInt64 | EVM chain id; 137 for Polygon mainnet |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in POL. It repeats on every log of the transaction, so count it once per transaction |
| Log_EnterIndex | UInt32 | Enter index of the emitting frame |
| Log_ExitIndex | UInt32 | Exit index of the emitting frame |
| Log_Index | UInt32 | Position of the log within the transaction |
| Log_LogAfterCallIndex | UInt32 | Index of the last call frame entered before this log, for ordering logs against calls |
| Log_Pc | UInt64 | Program counter at which the log opcode ran |
| Log_Signature_Abi | String | ABI fragment for the resolved event; empty when the topic is unknown |
| Log_Signature_Name | String | Event name, for example Transfer or Swap, when resolved |
| Log_Signature_Signature | String | Canonical event signature, for example Transfer(address,address,uint256) |
| Log_Signature_SignatureHash | String | Keccak hash of the event signature, hex; the same value as topic 0 |
| Log_Signature_SignatureType | String | How the event signature was resolved |
| Log_SmartContract | String | Contract that emitted the log, 0x-prefixed. Filter on this for one contract's events |
| LogHeader_Address | String | Address recorded in the log header, 0x-prefixed |
| LogHeader_Data | String | Raw non-indexed log data, hex |
| LogHeader_Index | UInt64 | Index of the log within the block, as the receipt records it |
| LogHeader_Removed | String | Whether the log was removed by a reorg; true or false |
| Topics_Hash | Array | Indexed topics of the log, as an array of hex strings; the first is the event signature hash |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| Transaction_To | String | Address the transaction called, 0x-prefixed |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |

### transfers: 24 columns

One row per native POL or token transfer on Polygon, with sender, receiver, token metadata and a USD value where a price exists.

S3 prefix: matic/transfers
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/transfers/82133800_82133849.parquet

| 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 POL, 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 |
| 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 POL, false for tokens. Native rows still carry the old symbol MATIC; filter on this column to find them |
| Transfer_Currency_ProtocolName | String | Token standard, for example erc20 or erc721; empty for native POL |
| Transfer_Currency_SmartContract | String | Contract of the transferred token, 0x-prefixed; the string 0x for native POL |
| 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 and call for every native POL movement, a plain send included; Polygon files never use transaction |
| Transfer_URI | String | Metadata URI for NFT transfers; empty otherwise |

### dex_trades: 54 columns

One row per DEX swap on Polygon, with both sides, pool and protocol, fees, transaction details and a USD value where a price exists.

S3 prefix: matic/dex_trades
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/dex_trades/94364043_94364092.parquet

| 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 POL, 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 and Polymarket shares, 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 and Polymarket shares |
| 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 POL |
| Trade_Buy_Currency_SmartContract | String | Contract of the bought token, 0x-prefixed; the string 0x for native POL |
| 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 and Polymarket, 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_Delegated | String | true when the pool ran through a delegate call, as proxy and clone pools do, else false; the implementation address is not included |
| 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, PancakeSwap, Balancer or Polymarket. Filter this column to exclude Polymarket order fills |
| 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_PoolId | String | 32-byte pool id, 0x-prefixed, for Uniswap v4 and PancakeSwap Infinity, whose pools share one contract; empty for other protocols |
| Trade_Sell_Amount | String | Amount 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_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 and Polymarket shares |
| 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 POL |
| Trade_Sell_Currency_SmartContract | String | Contract of the sold token, 0x-prefixed; the string 0x for native POL |
| 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 and Polymarket, 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 |
| Trade_Success | String | Whether this swap succeeded; true or false. A swap can fail inside a successful transaction, so filter on this column |

### miner_rewards: 27 columns

One row per block reward, splitting the validator's take into static, dynamic, transaction-fee and burnt components.

S3 prefix: matic/miner_rewards
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/matic/miner_rewards/82133800_82133849.parquet

| column | type | description |
| --- | --- | --- |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_TxCount | UInt32 | Number of transactions in the block |
| Block_Root | String | State root after the block |
| Block_UnclesCount | UInt32 | Number of uncles; always 0 on Polygon |
| Block_TxHash | String | Root of the transactions trie |
| Block_GasUsed | UInt64 | Total gas used by the block |
| Block_BaseFee | String | Base fee per gas of the block, in POL, as a decimal string |
| Block_Coinbase | String | Validator credited with the block, 0x-prefixed |
| Block_GasLimit | UInt64 | Gas limit of the block |
| Block_Date | Date | UTC date of the block |
| Block_Hash | String | Block hash, 0x-prefixed |
| Reward_BurntFees | String | POL burnt by the base fee across the block, as a decimal string |
| Reward_BurntFeesInUSD | Float64 | Burnt fees in USD at the block's hourly POL price |
| Reward_DynamicInUSD | Float64 | Dynamic reward component in USD |
| Reward_Dynamic | String | Dynamic reward component, as a decimal string |
| Reward_Static | String | Fixed block subsidy, as a decimal string. Polygon pays no protocol subsidy on Bor, so this is 0 |
| Reward_StaticInUSD | Float64 | Static reward in USD |
| Reward_Total | String | Total reward credited for the block, as a decimal string |
| Reward_TotalInUSD | Float64 | Total reward in USD |
| Reward_TxFees | String | Transaction fees paid to the validator, as a decimal string. On Polygon this is effectively the whole reward |
| Reward_TxFeesInUSD | Float64 | Transaction fees in USD |
| Reward_UncleInUSD | Float64 | Uncle reward in USD; always 0 on Polygon |
| Reward_Uncle | String | Uncle reward, as a decimal string; always 0 on Polygon |
| Uncle_Block_Number | UInt64 | Block height of the uncle; always 0 on Polygon |
| Uncle_Index | UInt32 | Index of the uncle; always 0 on Polygon |
| ChainId | UInt64 | EVM chain id; 137 for Polygon mainnet |

## Price

- Latest month (Aug 27, 2026 → Sep 27, 2026): $600 one-time, USD
- Last 12 months (Sep 27, 2025 → Sep 27, 2026): $3,600 one-time, USD
- Last 24 months (Sep 27, 2024 → Sep 27, 2026): $7,200 one-time, USD
- Full history (Genesis → Sep 27, 2026): $18,000 one-time, USD

Every window includes all 7 tables and 268 columns. Only the time range changes.

## Questions buyers ask

Q: What is included in the Polygon dataset?
A: 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.

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

Q: What is deliberately not in this dataset?
A: 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.

Q: So is Polymarket activity in the DEX trades table or not?
A: 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.

Q: Why is the S3 prefix matic and not polygon?
A: 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.

Q: Does Polygon have uncles? The schema has uncle columns.
A: 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.

Q: How are amounts and booleans encoded?
A: 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.

Q: How much of it is valued in USD?
A: 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.

Q: Are failed transactions included?
A: 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.

Q: How do I get one contract's activity?
A: 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.

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

Q: How is the data delivered, and how current is it?
A: 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.

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

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