# Base DEX Trades | Bitquery Data Store

Trades on Base DEXes since July 2023, one row per swap with both sides, the pool, fees and a USD value where a price exists.

Dataset page: https://bitquery.io/datastore/datasets/base-dex-trades
Network: Base
Category: Trades
Tables: 1
Columns: 54
Coverage: 2023-07-19 to 2026-09-24
Refresh: Daily
Rows: about 2.2B
Size: about 629 GB
Format: Apache Parquet, Snappy compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

We decode Base DEX trades from the chain ourselves: one row per swap, with the token bought, the token sold, the pool, the fees and the transaction around it. Each swap carries a USD value set from its safest side, a stablecoin or ETH before any other token, so one thin token cannot distort it. About 2.2 billion trades, from block 1,472,162 to yesterday.

Most buyers start with volume for one pool or token: filter the pool contract, or the pool id for Uniswap v4, and sum the USD column over successful swaps. A routed swap spans several rows, so group by transaction when you want what a trader did.

## What people use it for

- Aerodrome and Uniswap volume by pool, including v4 pools by id
- Price and volume history for any token, from its trades
- Trader and router activity, split by the address that signed
- Backtests on pool-level fills with fees

## Tables (1)

### dex_trades: 54 columns

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

S3 prefix: base/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/base/dex_trades/51730927_51730976.parquet
Sample updated: Sep 25, 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 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 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 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, Aerodrome or Balancer |
| 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 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 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 |

## Price

- Latest month (Aug 24, 2026 → Sep 24, 2026): $300 one-time, USD
- Last 12 months (Sep 24, 2025 → Sep 24, 2026): $2,000 one-time, USD
- Last 24 months (Sep 24, 2024 → Sep 24, 2026): $4,000 one-time, USD
- Full history (Jul 19, 2023 → Sep 24, 2026): $10,000 one-time, USD

Every window includes all 54 columns. Only the time range changes.

## Questions buyers ask

Q: What is in the Base DEX Trades dataset?
A: One Parquet table with 54 columns: one row per swap our indexer decodes on Base DEXes, with both sides, the pool, fees, the transaction and a USD value. Failed trades stay in with a flag, and NFT marketplace trades stay in too.

Q: How big is it?
A: About 2.2 billion trades over 39 months, roughly 629 GB as Parquet, estimated from the sample files. The last 24 months hold about 2.0 billion rows, the last 12 about 981 million and the latest month about 69 million. Row counts come from the live table; exact figures arrive with the delivery manifest.

Q: How far back does it go?
A: To the start of our index: from 19 July 2023, at block 1,472,162, the first swap in our index, to yesterday.

Q: Which DEXes are covered?
A: Aerodrome Slipstream, Uniswap v3 and v4, PancakeSwap v3 and Aerodrome v2 carry most of the last month's rows, with Uniswap v2, PancakeSwap Infinity, Zora, Balancer, Curve and Fluid behind them, 15 protocol names in the last month. The protocol name describes the pool design, so group by Trade_Dex_OwnerAddress, the factory, to split forks that share a design.

Q: What was left out, and why?
A: The export applies no filter of its own: failed trades, spam tokens and zero-value trades all stay in, and the columns let you drop them. Aerodrome pools changed label on 31 May 2026: Slipstream trades read uniswap_v3 before that day and aerodrome_slipstream after, and classic Aerodrome pools read aerodrome_v1 before and aerodrome_v2 after. Filter Trade_Dex_OwnerAddress to follow them across the change: Slipstream uses three factories, 0x5e7bb104d84c7cb9b682aac2f3d509f5f406809a, 0xf8f2eb4940cfe7d13603dddd87f123820fc061ef and 0xade65c38cd4849adba595a4323a8c7ddfe89716a, and classic pools 0x420dd381b31aef6683db6b902084cb0ffece40da.

Q: How are trades valued in USD?
A: Each swap takes its USD value from one side, the safer one: a stablecoin (USDC, the bridged USDbC, USDT and DAI) first, then ETH or WETH, then any other priced token, at the block's hourly price from Ethereum's hourly series for ETH, WETH and the stablecoins, since Base has no price series of its own; other tokens carry a USD value only when the other side is one of these. The same value goes on both sides, so a thin token cannot inflate a swap against ETH. On one sampled day a year, between 90% and 99% of trades had a stablecoin, ETH or WETH on one side; the free sample has a USD value on 91.3% of rows. A value of 0 means no price for either side.

Q: How are these produced, and how were they checked?
A: Decoded from Base by our own indexer, which reads each DEX's swap events and ties them to the transaction and the calling contract. USD values are added at export from our price series. Before release we ran the export query over blocks 51,730,927 to 51,731,026 and read the two sample files back: 4,823 trades, 54 columns, no empty values, USD on 91.3% of rows. Rerun over the blocks of our older 2026 sample file, it found the same 2,539 trades.

Q: How do I get volume for one pool or one token?
A: For one token, filter the contract column on either side to its address and sum Trade_Buy_AmountInUSD over successful swaps. For a v2 or v3 pool, filter Trade_Dex_SmartContract to the pool; for Uniswap v4 and PancakeSwap Infinity, filter Trade_PoolId, since their pools share one contract.

Q: What should I watch out for?
A: A routed swap through several pools is several rows: 34% of sample trades share a transaction with another swap, so sum by transaction for trader volume and by pool for DEX volume. The buyer address is usually a router; Transaction_From is the trader. Failed trades are 9.6% of the sample, some inside successful transactions, so filter Trade_Success. Trade_Dex_Delegated is true on 44% of the sample rows: Slipstream and Aerodrome pools are clones that run through a delegate call.

Q: How do I load it?
A: One line in DuckDB: SELECT * FROM read_parquet('dex_trades/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). The sample file opens without credentials.

Q: How current is it, and how is it delivered?
A: 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 and sorted ascending, under a stable S3 layout 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.

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