BitqueryBitqueryData Store
Ethereum logoEthereumLiquidityPoolsEvents

Uniswap V4 Liquidity

Decoded Uniswap V4 liquidity events on Ethereum since January 2025: Initialize, ModifyLiquidity and Donate, one row per event, in the standard events schema.

Coverage
Jan 31, 2025→ Oct 14, 2026 · yesterday
Rows
≈2.1Mrows · estimate
Size
≈1.0 GBParquet · estimate
Table
1univ4_liquidity_events
Columns
44typed
Coverage ends yesterday, UTC

Overview

We decode Uniswap V4 liquidity from Ethereum's event logs ourselves and keep only the events emitted by the Uniswap V4 PoolManager (0x000000000004444c5dc75cb358380d2e3de08a90). Forks that deploy the same PoolManager code are left out, because only the canonical contract is included. The table uses the same 44 columns as the events table of our Ethereum dataset, with nothing renamed or derived: Log_Signature_Name is the event, Call_Signature_Name is the method that ran, and Arguments holds the decoded values. A row is one event.

Initialize(id, currency0, currency1, fee, tickSpacing, hooks, sqrtPriceX96, tick) marks a new pool. ModifyLiquidity(id, sender, tickLower, tickUpper, liquidityDelta, salt) is an add when liquidityDelta is positive and a remove when it is negative. Donate(id, sender, amount0, amount1) gives tokens to in-range liquidity. V4 has no per-pool contract: the id argument is the pool and Log_SmartContract is always the PoolManager. Swaps are not in this dataset; they are in the Ethereum DEX Trades export, which joins on the transaction hash.

Use cases

  • Liquidity depth by tick for one pool id, rebuilt from ModifyLiquidity deltas
  • Pool launches by fee, tick spacing and hook contract, from Initialize
  • Hook adoption: liquidity added to pools with and without hooks
  • Donations to in-range liquidity, by pool and sender

Table

44 columns · free sample for the table

univ4_liquidity_events

44 columns

One row per Initialize, ModifyLiquidity or Donate event emitted by the Uniswap V4 PoolManager (0x000000000004444c5dc75cb358380d2e3de08a90), in the standard events schema.

ethereum/uniswap_v4_liquidity/univ4_liquidity_events<start_block>_<end_block>.parquet
Browse columns Sample fileSample updated Oct 15, 2026

Schema reference

copies a column name
44 columns
ColumnTypeDescription
Other2
ArgumentsStringDecoded event arguments as a JSON array, when the signature resolved; empty otherwise
ChainIdUInt64EVM chain id; 1 for Ethereum 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 ETH 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 ETH. It repeats on every log of the transaction, so count it once per transaction
Log10
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_Signature_AbiStringABI fragment for the resolved event; empty when the topic is unknown
Log_Signature_NameStringEvent name: Initialize, ModifyLiquidity or Donate
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 event, lowercase 0x hex: the PoolManager on every row
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
Sample file

Ask an AI about this data

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.

Start with

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:

# univ4_liquidity_events
ethereum/uniswap_v4_liquidity/univ4_liquidity_events<start_block>_<end_block>.parquet
  1. Download a free sampleNo email needed.
  2. Pay nowName, work email and licence check.
  3. Pay the invoiceBy card or bank transfer.
  4. 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 44 columns. Only the time range changes.

30 days
Latest month
Sep 14, 2026 → Oct 14, 2026
$200
Pay now
365 days
Last 12 months
Oct 14, 2025 → Oct 14, 2026
$2,000
Pay now
In every window
  • The univ4_liquidity_events table, 44 columns
  • Parquet files in the layout under Delivery
  • S3 or R2 download, chosen at checkout
  • Licensed under the Data License

FAQ

10 questions
What is in the Uniswap V4 Liquidity dataset?

One Parquet table, univ4_liquidity_events, with 44 columns in the standard Ethereum events schema. A row is one Initialize, ModifyLiquidity or Donate event emitted by the Uniswap V4 PoolManager (0x000000000004444c5dc75cb358380d2e3de08a90), from successful transactions and non-reverted calls only. Data starts on 31 January 2025.

How big is it?

About 2,100,000 rows and 1.0 GB of ZSTD Parquet from 31 January 2025 to 1 October 2026, estimated from sampled days. On 1 October 2026 the table had about 6,981 rows. On 1 April 2025 the PoolManager emitted 678 of these events, on 1 October 2025 2,807 and on 1 April 2026 3,536.

How do I read the amounts and addresses?

Arguments is a JSON array with one entry per decoded argument: index, name, path, type and the value slots. Addresses and bytes are hex strings; uint128 and uint256 amounts are decimal strings in raw token units, so divide by the token's decimals yourself; small integers such as ticks sit in the integer slots. Call_Value and Fee_SenderFee are already in ETH or POL.

Are swaps included?

No. Swaps are in the Ethereum DEX Trades dataset. Join on Transaction_Hash and the pool to see a swap next to the liquidity change around it.

What was left out, and why?

Forks that deploy the same PoolManager code are left out, because only the canonical contract is included. Events from failed transactions and reverted calls are left out, so each row is a change that took effect.

How does this differ from the Uniswap V3 Liquidity dataset?

Different protocol version, same schema and the same production method, so the two load side by side with one query.

How are these produced, and how were they checked?

The export is one ClickHouse query over our decoded Ethereum events, filtered to the contracts above. We checked the sample's row count against the independent count by event signature, confirmed each row has a decoded Arguments array and no duplicate (Transaction_Hash, Call_Index, Log_Index) key, and verified the Parquet schema matches the published Uniswap V3 Liquidity files column for column.

How do I load it?

With DuckDB: SELECT Log_Signature_Name, count(*) FROM read_parquet('univ4_liquidity_events/*.parquet') GROUP BY 1. pandas, Polars, Spark and ClickHouse read the same files.

How is the data delivered?

As flat Parquet files under a stable layout, one prefix per table, with a JSON manifest listing each 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.

Can I try before I buy?

Yes. The table links to a public sample file with 56 real rows from 1 October 2026, blocks 26,095,000 to 26,095,099. No email address required.