Creators mint & users sell NFTs on Rarible. Creators and users receive payments from sales & creators receive royalties from secondary sales.

Rarible is a non-custodial NFT marketplace protocol built on Ethereum. Rarible was founded by Alexander Salnikov and launched in 2020.

RARI tokenholders own and govern the protocol. They currently take all of the total transaction fees paid by traders (revenue). Rarible's investors include Coinbase Ventures, CoinFund, ParaFi Capital, etc.

governance

github

twitter

discord

etherscan

website

NFT marketplaces

Rarible

# Rarible Trading volume Methodology

## 1. Overview

Rarible trading volume measures the total USD value of all NFT trades executed across Rarible's marketplace infrastructure. This includes trades from multiple exchange contract versions (v1, v2) and direct token sale contracts across Ethereum and Polygon networks. The calculation aggregates transaction values from exchange function calls, direct purchase/bid functions, order matching mechanisms, and token sale events, then converts them to USD using end-of-day price feeds.

## 2. Data sources

- **Ethereum function call traces**: Rarible Exchange v1 and v1.2 contract function calls for NFT trades
- **Ethereum and Polygon function call traces**: Rarible Exchange v2 contract function calls including direct purchases, bid acceptance, and order matching
- **Ethereum event logs**: Direct token sale events from ERC721Sale, ERC1155Sale, and TokenSale contracts
- **Royalty registry data**: Function call traces from Ethereum and Polygon royalty registry contracts providing fee tier information
- **Token metadata**: ERC-20 token information for address validation and decimal precision
- **End-of-day price feeds**: Token price data for USD conversion

## 3. Step-by-step calculation

### Component A: Rarible exchange v1 trades
- **Purpose**: Captures trades from the original Rarible exchange contracts (v1 and v1.2) on Ethereum
- **Logic**: Processes `exchange` function calls from ExchangeV1 and ExchangeV12 contracts. Determines the payment token by checking if `buyAsset.tokenId` equals zero (indicating fungible token vs NFT). Calculates trade amounts by applying buy/sell asset ratios when needed. Extracts fee tiers by combining `buyerFee` and `sellerFee` parameters and dividing by 10,000 to convert to percentage. When the transaction `value` field is zero, adds half the calculated fee to the base `amount` to represent the true trade value
- **Key fields**: `token_address` (payment token), `amount` (base trade value), `fee_tier` (combined buyer and seller fees), `total_amount` (ETH value of transaction)

### Component B: Rarible exchange v2 direct trades  
- **Purpose**: Captures direct purchase and bid acceptance trades from Rarible Exchange v2 contracts
- **Logic**: Processes `directPurchase` and `directAcceptBid` function calls from Ethereum and Polygon v2 contracts. For purchases, uses the buyer's address and sell order payment amount. For bids, uses the seller's address and takes the minimum of bid and sell order amounts to handle edge cases. Extracts fee tiers by parsing the last 5 characters of order data fields and combining buyer and seller fees. Handles native token trades by replacing null addresses with wrapped native token addresses (WETH, WMATIC). Joins with royalty registry data to calculate royalty amounts based on token and recipient matching
- **Key fields**: `paymentToken` (from order data), `buyOrderPaymentAmount` or `bidPaymentAmount`, `sellOrderData` and `buyOrderData` (for fee extraction), `royalty_tier` (from registry lookup)

### Component C: Rarible exchange v2 match trades
- **Purpose**: Captures trades from Rarible's order matching system where buy and sell orders are matched
- **Logic**: Processes `matchOrders` function calls from v2 contracts. Extracts payment token addresses by parsing asset type data from order structures, looking for 40-character hex strings starting at position 27. Determines amounts by taking the minimum value between left order take asset and right order make asset, or left order make asset and right order take asset, depending on which represents the payment token. Uses token metadata lookup to validate extracted addresses. Calculates fee tiers by combining fee data from both left and right orders. Applies royalty calculations through registry joins
- **Key fields**: `makeAsset.assetType.data` and `takeAsset.assetType.data` (for token extraction), `makeAsset.value` and `takeAsset.value` (for amounts), order `Data` fields (for fees)

### Component D: Direct token trades
- **Purpose**: Captures direct NFT sales through dedicated sale contracts for different token standards
- **Logic**: Processes `Buy` events from ERC721Sale, ERC1155Sale, and TokenSale contracts, plus `buy` function calls from v2 sale contracts. For ERC1155 tokens, multiplies `price` by `value` (quantity) to get total trade amount. For ERC721 tokens, uses `price` directly since each token is unique. All trades use WETH as the payment token address. For v2 function calls, calculates fees by multiplying `sellerFee` by price and adjusting for different token standards (ERC1155 fees are multiplied by 2)
- **Key fields**: `price` (trade price), `value` or `buying` (quantity for ERC1155), `sellerFee` (fee percentage)

### Final aggregation
- **Combining components**: All four trade components are combined using union operations, creating a unified dataset with consistent field mapping including `timestamp`, `amount`, `token_address`, and metadata fields
- **Currency conversion**: Raw token amounts are corrected for decimal precision using token metadata, then converted to USD using end-of-day price feeds through the `convert_to_usd_and_correct_decimals` macro
- **Time aggregation**: All trades are aggregated to daily boundaries using `timestamp_trunc` to day level, with trade volumes summed by day
- **Final calculation**: The daily trading volume represents the total USD value of all Rarible trades for each day, including exchange trades, direct sales, and matched orders, with missing days filled with zero values

*This methodology was automatically generated by Token Terminal's methodology analyzer.*

Total value of spot trades executed on the exchange.

RaribleRARI

Trading volume

Trading volume

Competitive landscape

Chain breakdown