Base batches users' transactions and submits them to Ethereum, paying a share of the transaction fees to Ethereum validators (expense).

Base is an Ethereum Layer 2 (L2) offering a secure, low-cost, builder-friendly way for anyone, anywhere, to build onchain.

Coinbase team owns and governs the protocol. Coinbase is a public company and its investors include Andreessen Horowitz, Vanguard Group, ARK Investment Management, etc.

github

twitter

discord

website

Blockchains (L2)

Base

# Base Active users (monthly) Methodology

## 1. Overview

Base Monthly Active Users (MAU) measures the number of unique addresses that initiated at least one transaction on the Base blockchain within a 30-day rolling window. This metric provides insight into user engagement and adoption of the Base Layer 2 network. The calculation uses HyperLogLog data structures to efficiently count unique users across overlapping time windows and provides multiple dimensional breakdowns for analysis.

## 2. Data sources

- **Base blockchain transactions**: Raw transaction records from the Base Layer 2 blockchain, including transaction metadata such as sender addresses, transaction hashes, and block timestamps
- **Block timestamp data**: Precise timing information for when transactions were included in Base blockchain blocks
- **Transaction sender addresses**: The `from_address` field identifying the initiating address for each transaction

## 3. Step-by-step calculation

### Component A: Daily active user extraction
- **Purpose**: Identifies unique active users on a daily basis from Base blockchain transactions
- **Logic**: Extracts transaction records from Base blockchain data, truncating block timestamps to daily granularity. Each unique sender address (`from_address`) is identified as an active user for that day. The component filters transactions to focus on transaction senders and applies incremental processing logic to handle only recent data when running updates.
- **Key fields**: Daily timestamp boundary (`timestamp`), sender address (`user_address`), chain identifier (`chain`), user classification (`user_type` as "Transaction sender"), and business categorization fields

### Component B: HyperLogLog preparation
- **Purpose**: Converts daily active user data into HyperLogLog data structures for efficient unique counting across time windows
- **Logic**: Takes the daily active users and creates HyperLogLog sketches using `hll_count.init` function with precision parameter 15. Groups data by timestamp, chain, user type, and product dimensions to maintain proper dimensional breakdowns. This allows efficient approximate counting of unique users when aggregating across multiple days.
- **Key fields**: Daily timestamp (`timestamp`), chain identifier (`chain_id`), user type classification (`user_type`), product identifier (`product_id`), and HLL sketch (`hll`)

### Component C: Datespine generation
- **Purpose**: Creates a complete sequence of dates to ensure no gaps in the time series analysis
- **Logic**: Generates a continuous array of daily timestamps from the earliest available data through the current date minus one day. Uses `generate_timestamp_array` to create this comprehensive date range, ensuring that even days with no activity are represented in the final dataset.
- **Key fields**: Complete daily timestamp sequence (`timestamp`)

### Component D: Rolling window creation
- **Purpose**: Establishes 30-day rolling windows for each date in the datespine
- **Logic**: For each date in the datespine, creates a 30-day window including the current date plus the previous 29 days. Uses cross-join logic with `unnest` and `generate_timestamp_array` to create all date combinations. Each row represents a specific date with its associated window date, enabling proper aggregation across the rolling period.
- **Key fields**: Target date (`timestamp`) and window date (`joinday`)

### Component E: Window-based HLL aggregation
- **Purpose**: Combines HyperLogLog data across 30-day rolling windows
- **Logic**: Joins the rolling window dates with the daily HLL data to gather all HLL sketches that fall within each 30-day period. Applies incremental filtering to process only necessary date ranges when running updates. This creates the foundation for calculating unique users across each rolling window.
- **Key fields**: Target timestamp (`timestamp`), dimensional attributes (`chain_id`, `user_type`, `product_id`), and HLL sketches (`hll`)

### Component F: Dimensional breakdowns
- **Purpose**: Creates multiple analytical views of MAU data across different dimensions
- **Logic**: Generates four distinct dimensional breakdowns:
  - Project-level: Aggregates all MAU data at the overall Base project level
  - Chain-level: Breaks down MAU by specific chain (Base in this case)  
  - User-type-level: Segments MAU by user classification (Transaction sender)
  - Product-level: Analyzes MAU by product categories (if applicable)
Each breakdown merges HLL sketches using `hll_count.merge_partial` and extracts final counts using `hll_count.extract`.
- **Key fields**: Timestamp (`timestamp`), dimension type (`dimensions`), dimensional values (`chain_id`, `user_type`, `product_id`), and calculated MAU count (`user_mau`)

### Final aggregation
- **Combining components**: All dimensional breakdowns are combined using union operations to create a comprehensive dataset with multiple analytical perspectives
- **Time aggregation**: Data is aggregated at daily granularity with 30-day rolling windows, meaning each day shows the unique user count for that day plus the previous 29 days
- **Final calculation**: The final MAU value for each date represents the approximate count of unique addresses that sent at least one transaction within the 30-day rolling window ending on that date, calculated using HyperLogLog merge and extract operations for computational efficiency

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

Unique revenue-generating users over a rolling 30-day window.

Base

Active users (monthly)

Active users (monthly)

Competitive landscape

Chain breakdown