Polymarket fills, position splits, merges and payouts, and market results on Polygon since September 2025, with market titles, outcomes and USD values.
We decode Polymarket from Polygon ourselves: the order fills on its exchanges, the splits, merges and payouts of positions, and the markets created and decided, each tied to the market's question and outcome names. About 1.80 billion fills and 1.11 billion settlement rows since 1 September 2025, valued in USD from the cash side.
Most buyers start with volume for a market or a wallet. Take fills where Trade_IsTakerSide is false for volume, then join payouts on the condition id to see what each market paid out once it was decided. The winner sits on the Resolved row in the markets table.
Use cases
Wallet trade history per market or per address, with the price and fee of every fill
Price history per outcome at fill level
Market life from creation to result and payout
Fee income per market since fees began in January 2026
3 tables
120 columns · free sample for each table
prediction_trades
49 columns
One row per order fill on Polymarket's exchanges, with both addresses, shares, price, fee, USD value and the market question and outcome.
matic/polymarket/prediction_trades<start_block>_<end_block>.parquet50 blocks per file
prediction_trades49 columnsOne row per order fill on Polymarket's exchanges, with both addresses, shares, price, fee, USD value and the market question and outcome.
ColumnTypeDescription
Block3
Block_NumberUInt64Polygon block of the fill.
Block_TimeDateTimeTime of the fill's block, UTC.
Block_DateDateUTC date of the fill.
Call2
Call_Signature_NameStringExchange function that made the fill: matchOrders.
Call_IndexUInt32Index of the call inside the transaction. With Transaction_Hash and Log_Index it gives a unique row key.
Log3
Log_Signature_NameStringEvent name: OrderFilled.
Log_SmartContractStringExchange contract that emitted the event.
Log_IndexUInt32Index of the event inside its call; it restarts in each call.
Trade_OutcomeTrade13
Trade_OutcomeTrade_BuyerStringAddress that got the outcome shares. When it is the exchange contract, the row is the taker's side of a match (see Trade_IsTakerSide).
Trade_OutcomeTrade_SellerStringAddress that gave up the outcome shares.
Trade_OutcomeTrade_AmountDecimalShares filled, to 6 decimal places.
Trade_OutcomeTrade_CollateralAmountDecimalCash paid or received for those shares: USDC.e before April 2026, pUSD after.
Trade_OutcomeTrade_CollateralAmountInUSDDecimalThe cash amount times the hourly USDC.e price.
Trade_OutcomeTrade_OrderIdStringOrder hash, stored as its hex text hex-encoded again, as in the earlier sample.
Trade_OutcomeTrade_PriceDecimalPrice per share in cash: CollateralAmount / Amount, between 0 and 1.
Trade_OutcomeTrade_PriceInUSDDecimalPrice times the hourly USDC.e price.
Trade_OutcomeTrade_IsOutcomeBuyBoolTrue when the order bought outcome shares.
Trade_OutcomeTrade_Fee_AmountDecimalFee charged on this fill, in the cash token; 0 on every fill before January 2026.
Trade_OutcomeTrade_Fee_Currency_SymbolStringFee token symbol; empty when there is no fee.
Trade_OutcomeTrade_Fee_PayerStringAddress that paid the fee.
Trade_OutcomeTrade_Fee_RecipientStringAddress that got the fee.
Trade_Prediction24
Trade_Prediction_CollateralToken_NameStringName of the cash token.
Trade_Prediction_CollateralToken_SymbolStringCash token symbol: USDC (the bridged USDC.e) or pUSD.
Trade_Prediction_Question_TitleStringThe market question as shown on the site. Filled from the markets table when the fill lacks it.
Trade_Prediction_Question_ResolutionSourceStringSource named to decide the market.
Trade_Prediction_Question_ImageStringImage URL shown with the market.
Trade_Prediction_Question_MarketIdStringNumeric market id on the site.
Trade_Prediction_Question_IdStringId of the question behind the condition.
Trade_Prediction_Question_CreatedAtDateTimeWhen the market was created, UTC.
Trade_Prediction_Question_GroupIdStringEvent id that groups related markets; 0x when the market stands alone.
Trade_Prediction_Outcome_IdStringOutcome position id, the same as OutcomeToken_AssetId.
Trade_Prediction_Outcome_IndexInt32The outcome's index in its condition, from 0.
Trade_Prediction_Outcome_LabelStringOutcome name, such as Yes, No, Up or Down; taken from the market's outcome list when the fill has none.
Transaction2
Transaction_FromStringAddress that sent the transaction. Fills arrive through matchOrders calls sent by Polymarket's relayers (about 2,000 addresses on a sampled day), so this is not the person on either side.
Transaction_HashStringHash of the fill's transaction.
TransactionStatus1
TransactionStatus_SuccessBoolFalse when the transaction failed.
Trade1
Trade_IsTakerSideBoolTrue when the exchange contract is the buyer or seller: the row restates the taker's side of a match whose maker rows are already there. Sum rows where it is false for market volume.
prediction_settlements42 columnsOne row per split, merge or payout of positions on the Conditional Tokens contracts, with the holder, shares, cash and USD value.
ColumnTypeDescription
Block3
Block_NumberUInt64Polygon block of the event.
Block_TimeDateTimeTime of the block, UTC.
Block_DateDateUTC date of the event.
Call2
Call_Signature_NameStringFunction called: splitPosition, mergePositions or redeemPositions.
Call_IndexUInt32Call position in the transaction; part of the row key with Transaction_Hash and Log_Index.
Log3
Log_Signature_NameStringEvent name: PositionSplit, PositionsMerge or PayoutRedemption.
Log_SmartContractStringContract that emitted the event: Conditional Tokens or the NegRisk adapter.
Log_IndexUInt32Event position within its call, counted from 0 in each call.
Settlement3
Settlement_EventTypeStringSplit, Merge or Redemption.
Settlement_HolderStringAddress whose cash or positions moved. It is a Polymarket exchange or adapter contract on 99% of splits since September 2025, and a contract redeeming for the trader on 78 to 91% of payout rows per month since May 2026.
Settlement_OutcomeTokenIdsStringERC-1155 position ids involved, as text in the form ['id1', 'id2'].
Settlement_Amounts4
Settlement_Amounts_AmountDecimalShares split, merged or redeemed, to 6 decimal places.
Settlement_Amounts_AmountInUSDDecimalUSD value of those shares at the time, equal to CollateralAmountInUSD. The earlier sample files carried 0 here.
Settlement_Amounts_CollateralAmountDecimalCash locked by a split, freed by a merge, or paid out by a redemption (0 for a losing position).
Settlement_Amounts_CollateralAmountInUSDDecimalThe cash amount times the hourly USDC.e price; 0 for cash tokens outside Polymarket's own (under 0.1% of rows).
Settlement_Prediction25
Settlement_Prediction_CollateralToken_AssetIdStringAsset id of the cash token; 0 for ERC-20.
Settlement_Prediction_CollateralToken_BalanceSlotIndexStringStorage slot of the cash token's balances; empty when 0.
Settlement_Prediction_CollateralToken_DecimalsInt32Cash token decimals: 6 for Polymarket's cash tokens.
Settlement_Prediction_CollateralToken_SmartContractStringContract of the cash token.
Settlement_Prediction_CollateralToken_SymbolStringCash symbol: USDC (the bridged USDC.e), WCOL (the NegRisk adapter's wrapped USDC.e) or pUSD.
Settlement_Prediction_ConditionIdStringCondition id of the market, used to join fills and market events.
Settlement_Prediction_Marketplace_SmartContractStringConditional Tokens contract or the NegRisk adapter.
Settlement_Prediction_Marketplace_ProtocolNameStringName of the protocol: polymarket.
Settlement_Prediction_Marketplace_ProtocolFamilyStringFamily of the protocol: Gnosis_CTF.
Settlement_Prediction_Outcome_LabelStringOutcome name; empty on splits and merges, which cover every outcome of the market.
Settlement_Prediction_Outcome_IndexInt32Index of the outcome, from 0.
Settlement_Prediction_Outcome_IdStringOutcome position id.
Settlement_Prediction_OutcomeToken_SmartContractStringERC-1155 contract of the position.
Settlement_Prediction_OutcomeToken_SymbolStringSymbol of the position token; usually empty.
Settlement_Prediction_OutcomeToken_AssetIdStringERC-1155 token id of the position.
Settlement_Prediction_OutcomeToken_BalanceSlotIndexStringStorage slot of the position balances; empty when 0.
prediction_managements29 columnsOne row per outcome of a new market and one per market decided, with the question, rules, outcomes, oracle and, on decided markets, the winner.
ColumnTypeDescription
Block3
Block_NumberUInt64Polygon block of the market event.
Block_TimeDateTimeBlock time in UTC.
Block_DateDateUTC date of the market event.
Call2
Call_Signature_NameStringFunction that made the event.
Call_IndexUInt32Call number within the transaction, part of the row key.
Log3
Log_Signature_NameStringEvent name: TokenRegistered for a new market, ConditionResolution for a decided one.
Log_SmartContractStringContract that emitted the event.
Log_IndexUInt32Event number within its call; it restarts per call.
Management2
Management_EventTypeStringCreated (one row per outcome token of a new market) or Resolved (one row per decided market).
Management_DescriptionStringThe market's full rules text.
Management_Group3
Management_Group_IdStringEvent id that groups related markets; 0x when none.
Management_Group_TitleStringTitle of that event.
Management_Group_DescriptionStringText that explains that event.
Management_Prediction14
Management_Prediction_Question_IdStringQuestion id, as in the other two tables.
Management_Prediction_Question_MarketIdStringThe site's numeric id for the market.
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:
# prediction_trades: 50 blocks per file
matic/polymarket/prediction_trades<start_block>_<end_block>.parquet# prediction_settlements: 50 blocks per file
matic/polymarket/PredictionSettlements<start_block>_<end_block>.parquet# prediction_managements: 50 blocks per file
matic/polymarket/prediction_managements<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 3 tables and 120 columns. Only the time range changes.
Three Parquet tables joined by one key, the market's condition id. The trades table has one row per order fill on Polymarket's exchanges, with both addresses, shares, price, fee and the market question. The settlements table has one row per split, merge or payout of positions, with the shares and cash each one moved. The markets table has a row for each outcome of a new market and one row per market decided, naming the winner.
How big is it?
About 1.80 billion fills, 1.11 billion settlement rows and 5.4 million market events since 1 September 2025, roughly 374 GB as Parquet, going by the sample files. The last 6 months hold about 1.07 billion fills and the latest month about 120 million. Row counts come from the live tables; exact figures arrive with the delivery manifest.
How far back does it go?
From 1 September 2025, the first day of steady coverage in our index, to yesterday. Polymarket has run since 2020; the months before September 2025 are not in our index.
How do I get market volume without counting fills twice?
Use the rows where Trade_IsTakerSide is false. Each match also writes one row for the taker's side, with the exchange contract as buyer or seller, and those rows are 34 to 44% of each month. Summing every row nearly doubles volume. When both sides buy opposite outcomes, the exchange mints the shares and the two sides pay different prices, so maker and taker volume differ; maker rows are the rule our API uses.
Which markets are covered?
Markets on the main exchange and on the NegRisk exchange for events with many outcomes, and on the new exchange contracts that took over from both in April 2026. About 2.3 million markets had fills in the period. Short Up or Down crypto markets are 61 to 85% of fills on the main exchange in each month.
How do I find who won and what was paid out?
Resolved rows in the markets table name the winning outcome, and payout rows in the settlements table give the cash paid; join on the condition id. On NegRisk markets nearly every payout appears twice, once from Conditional Tokens with the NegRisk adapter as holder and once from the adapter itself, so summing every row overstates cash paid by 15 to 30% per month. Drop the Conditional Tokens rows held by the adapter and keep its own row, which names the address that redeemed. From May 2026, 93 to 98% of the cash paid each month went through contracts that redeem positions for traders, and those rows name the contract as holder.
How are fills valued in USD?
Cash amount times the hourly price of USDC.e from our own price series. Polymarket settles in USDC.e until April 2026 and in pUSD after, and the NegRisk adapter wraps USDC.e as WCOL; all three are priced as USDC.e. Price is cash per share, between 0 and 1. The few settlements in any other token carry a USD value of 0.
How are these produced, and how were they checked?
Decoded from Polygon by our own indexer, which reads the exchange and Conditional Tokens events and ties each to its market's question and outcomes. Before release we ran the export queries over blocks 94,364,050 to 94,364,149: 6,976 fills, 4,110 settlement rows and 147 market events, each equal to the source table, with no repeated keys and every price between 0.001 and 0.999. A full day, 23 September 2026, matched the source row counts for all three tables.
What should I watch out for?
Fees start in January 2026: every fill before then shows 0, and since then 35 to 84% of fills a month carry one, paid in the cash token. Transaction_From is a Polymarket relayer, not either person in the fill; use buyer and seller. Since September 2025, 99% of splits name a Polymarket exchange or adapter contract as the holder, and no month is below 93%. Log_Index restarts inside each call, so key rows on hash, call index and log index.
How do I load it?
One line in DuckDB: SELECT * FROM read_parquet('prediction_trades/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). The sample files open without a login.
How current is it, and how is it delivered?
Refreshed daily with T+1 latency, so a purchase made today includes everything to yesterday. Delivered as Parquet named by block range, 50 blocks per file, under a stable layout 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. Polygon DEX Trades also carries Polymarket fills since February 2026, as swaps without market titles or payouts.
PolymarketTradesEvents
SolanaLast 12 months
RobinhoodFull history