BitqueryBitqueryData Store
Ethereum logoEthereumPoolsEvents

Uniswap V3 Positions

Decoded Uniswap V3 position NFT events on Ethereum: one row per liquidity increase, decrease, fee collection and transfer, with the method that ran.

Coverage
May 4, 2021→ Oct 11, 2026 · yesterday
Rows
≈121Krows · estimate
Size
≈230 MBParquet · estimate
Table
1univ3_position_events
Columns
44typed
Refresh: dailyCoverage ends yesterday, UTC

Overview

We decode the events of Uniswap V3's position NFT contract on Ethereum: opening a position, adding liquidity, removing it, collecting fees and moving the NFT. The table uses the same 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 token id and the amounts. A row is one event on one position.

Most buyers follow a position: filter on the tokenId argument and read its rows in block order. Add the liquidity argument on IncreaseLiquidity rows and subtract it on DecreaseLiquidity rows for the open size, and take the owner from the latest Transfer row. This listing sells the latest month; the Uniswap V3 Liquidity dataset has the same table since May 2021 together with pool-level events.

Use cases

  • Position history for one NFT: deposits, withdrawals and collected fees
  • Liquidity provider activity by wallet
  • New and closed positions by day
  • Position NFT ownership changes between wallets and vaults

Table

44 columns · free sample for the table

univ3_position_events

44 columns

One row per IncreaseLiquidity, DecreaseLiquidity, Collect or Transfer event of the position NFT contract, in the standard events schema; Arguments holds the token id, liquidity and token amounts.

ethereum/uniswap_v3_liquidity/univ3_position_events<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Oct 12, 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, 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
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:

# univ3_position_events: 50 blocks per file, sorted ascending
ethereum/uniswap_v3_liquidity/univ3_position_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.

Price

Latest month
Sep 11, 2026 → Oct 11, 2026
$300one-time, USD
  • The univ3_position_events table, 44 columns
  • Parquet files in the layout under Delivery
  • S3 or R2 download, chosen at checkout
  • Licensed under the Data License
Pay now

FAQ

12 questions
What is in the Uniswap V3 Positions dataset?

One Parquet table with 44 columns: one row per IncreaseLiquidity, DecreaseLiquidity, Collect and Transfer event of the Uniswap V3 position NFT contract on Ethereum, 0xC36442b4a4522E871399CD717aBDD847Ab11FE88. The columns are those of our Ethereum events table, less Log_Pc.

How big is it?

The latest month holds about 121,000 rows, counted for 12 September to 11 October 2026: 43,540 collections, 29,173 transfers, 28,263 increases and 19,694 decreases. That is roughly 230 MB as Parquet, a rough estimate from the 17 rows of the sample files; exact figures arrive with the delivery manifest.

How far back does it go?

This listing covers the latest month. The same table since 4 May 2021, about 7.5 million rows over 1.38 million positions, is part of the Uniswap V3 Liquidity dataset.

How do I tell a new position from an addition to an existing one?

Read Call_Signature_Name with Log_Signature_Name. mint with IncreaseLiquidity opens a new position, and the same call also emits a Transfer from the zero address. increaseLiquidity with IncreaseLiquidity adds to an existing position. decreaseLiquidity with DecreaseLiquidity removes liquidity, collect with Collect pays out owed tokens and fees, and burn with Transfer closes the NFT. From 4 to 10 October 2026, 3,975 increases came from mint and 2,200 from increaseLiquidity.

How do I read the token id and the amounts?

Arguments is a JSON array with one entry per decoded argument: its position, name, type and a value list. Addresses sit in the hex slot of that list without the 0x prefix, uint128 and uint256 amounts in the string slot as raw integers. The token id is the tokenId argument. Token amounts are in raw units, so divide by 10 to the power of the token decimals.

How do I get the current state of a position?

Filter on the tokenId argument. The open liquidity is the sum of the liquidity argument on IncreaseLiquidity rows minus the sum on DecreaseLiquidity rows, and the owner is the to argument of the latest Transfer row; the zero address means the NFT was burned. A position opened before the month you bought needs its earlier rows for a full total.

Where are the pool and the tick range?

The position NFT contract's events carry the token id but not the pool or the ticks; those are on the pool event the same call caused. That table is in the Uniswap V3 Liquidity dataset; join it on Transaction_Hash where its Call_CallerIndex equals the position row's Call_Index. On 11 October 2026 all 683 increases, 522 decreases and 945 collections had a matching pool event.

What was left out, and why?

Positions opened straight on a pool by a vault or a custom contract are left out, because they have no position NFT; they are in the Uniswap V3 Liquidity dataset. Approval events are left out. Events from failed transactions and reverted calls are left out. There are no USD or decimal-adjusted columns; amounts are the raw integers from the logs.

How are these produced, and how were they checked?

Decoded from Ethereum by our own indexer, then filtered at export. We ran the export for the blocks of our Ethereum events sample file of 20 December 2025: its 19 position rows matched that file in all 44 columns. For 20 September 2026 the row count equalled a plain count of the source, 2,883 rows, with no repeated row keys.

What should I watch out for?

The liquidity argument is Uniswap's raw L value, not a token amount. A decrease only marks tokens as owed; they are paid on Collect, and a Collect pays owed principal and fees together, so fee income is collected minus decreased amounts. Fees earned but not yet collected do not appear in logs. Log_Index restarts in each call frame, so the row key is Transaction_Hash, Call_Index and Log_Index.

How do I load it?

One line in DuckDB: SELECT * FROM read_parquet('univ3_position_events/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). Arguments is a JSON string, so parse it with json_extract in DuckDB or json.loads in Python. The sample files open without credentials.

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 and sorted ascending, 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.