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 Fees Methodology

## 1. Overview

Rarible fees represents the total protocol and royalty fees collected by the Rarible NFT marketplace across all supported chains and exchange versions. This metric captures platform fees from NFT trades, direct purchases, bid acceptances, and royalty payments, providing a comprehensive view of Rarible's fee revenue. The calculation aggregates fees from multiple exchange contract versions and trade types, converting all amounts to USD for standardized reporting.

## 2. Data sources

- **Ethereum function call traces**: Rarible v1 and v2 exchange contract function calls for `exchange`, `directPurchase`, `directAcceptBid`, and `matchOrders` operations
- **Polygon function call traces**: Rarible v1 exchange contract function calls for `directPurchase`, `directAcceptBid`, and `matchOrders` operations  
- **Ethereum event logs**: `Buy` events from `ERC721Sale`, `ERC1155Sale`, and `TokenSale` contracts for direct NFT purchases
- **Ethereum and Polygon function call traces**: `getRoyalties` function calls from `RoyaltyRegistry` and `RoyaltiesRegistry` contracts
- **Token metadata**: Chain-specific token information for identifying payment tokens vs NFT assets
- **End-of-day token price feeds**: USD exchange rates for native tokens (ETH, MATIC) and ERC20 payment tokens

## 3. Step-by-step calculation

### Component A: Exchange v1 trades
- **Purpose**: Calculate fees from Rarible v1 exchange trades on Ethereum
- **Logic**: Process function call traces from `ExchangeV1_exchange` and `ExchangeV12_exchange` contracts. Extract buyer and seller fee rates from function parameters, sum them together and divide by 10,000 to get decimal fee percentage. Determine payment token by checking if trade involves fungible tokens (tokenId = '0'). Calculate trade amounts based on order ratios when needed. For fee calculation, multiply trade amount by fee tier. Adjust final amounts by adding half the fee amount when no ETH value was sent with transaction, otherwise use the ETH value sent
- **Key fields**: `buyerFee` and `sellerFee` parameters for fee rates, `buying`, `selling`, and `amount` for trade calculations, `value` for ETH amounts

### Component B: Exchange v2 direct trades  
- **Purpose**: Calculate fees from direct purchase and bid acceptance trades on v2 exchange
- **Logic**: Process `directPurchase` and `directAcceptBid` function calls from Ethereum and Polygon. Extract fee tiers by parsing the last 5 characters of `sellOrderData` and `buyOrderData` (or `bidData`) fields as hexadecimal, converting to integers, summing, and dividing by 10,000. Handle null payment token addresses by substituting wrapped native tokens. For purchases, use total ETH value sent; for bids, calculate amount plus half the fee. Join with royalty registry data based on transaction hash and trace address to add royalty amounts to platform fees
- **Key fields**: `sellOrderData` and `buyOrderData` for fee extraction, `paymentToken` for token identification, `buyOrderPaymentAmount` and `bidPaymentAmount` for trade amounts

### Component C: Exchange v2 matched orders
- **Purpose**: Calculate fees from order matching trades on v2 exchange  
- **Logic**: Process `matchOrders` function calls from Ethereum and Polygon. Extract fee tiers from both left and right order data fields using the same hexadecimal parsing approach. Determine payment token by analyzing `makeAsset` and `takeAsset` data fields, extracting token addresses and checking against known token lists. Calculate trade amounts using the lesser value between opposing make/take asset amounts. Add royalty amounts from registry lookups. For total amounts, add half the fee to trade amount when no ETH was sent, otherwise use ETH value
- **Key fields**: `orderLeft.Data` and `orderRight.Data` for fees, `makeAsset` and `takeAsset` for token and amount identification

### Component D: Token sale trades
- **Purpose**: Calculate fees from direct NFT purchase events and functions
- **Logic**: Process `Buy` events from `ERC721Sale`, `ERC1155Sale`, and `TokenSale` contracts, plus `buy` function calls from v2 sale contracts. For events, fees are not explicitly available so set to null. For function calls, extract seller fee rates and multiply by trade amounts. Handle ERC1155 quantities by multiplying price by token amount. All sales are assumed to use WETH as payment token. For v2 functions, calculate fees as seller fee rate divided by 10,000 multiplied by trade price
- **Key fields**: `price` and `value` for trade amounts, `sellerFee` for fee rates, `buying` for ERC1155 quantities

### Component E: Royalty registry lookups
- **Purpose**: Provide dynamic royalty rates for trades
- **Logic**: Process `getRoyalties` function calls from royalty registry contracts on Ethereum and Polygon. Extract royalty recipient addresses and rates from function outputs. Convert royalty values to decimal percentages by dividing by 10,000. Join this data with trade records based on transaction hash and trace address to add royalty fees to platform fees
- **Key fields**: `token` for NFT address, `account` for royalty recipient, `value` for royalty rate

### Final aggregation
- **Combining components**: Union all trade types (v1 exchange, v2 direct, v2 matched, token sales) and sum their fee amounts. For v1 trades, use calculated fee amounts directly. For v2 trades, sum platform fees plus royalty amounts. For token sales, use seller fees where available
- **Currency conversion**: Apply end-of-day USD exchange rates to fee amounts with proper decimal adjustments based on token precision (18 decimals for ETH/MATIC, variable for ERC20 tokens)  
- **Time aggregation**: Group all fees by day using timestamp truncation to daily boundaries in UTC timezone
- **Final calculation**: Sum all fee amounts by day, chain, token address, market sector, business segment, and product classifications to produce daily total fees in USD

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

Total value users pay to use a protocol (gross fees, user-paid fees).

RaribleRARI

Fees

Fees

Competitive landscape

Chain breakdown