# L2BEAT Rollup TVL Scraper (`acquistion-automation/l2beat-rollup-tvl-scraper`) Actor

Scrapes L2BEAT rollup projects with total value locked, maturity stage, category, and links. Filter by layer type, rollup category, stage, and archived status. Returns a flat row per project.

- **URL**: https://apify.com/acquistion-automation/l2beat-rollup-tvl-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![Acquisition Automation Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## 🔗 L2BEAT Rollup TVL Scraper

> **Export every Ethereum rollup L2BEAT tracks as a row: value secured broken into native, canonical and external, the 7 day change, the maturity stage, the rollup category, the stack it runs on, and L2BEAT's five risk verdicts.** 20 fields per project. No API key, no registration, no login.

L2BEAT is the reference scoreboard for Ethereum scaling. It ranks rollups by the value they secure and grades each one on sequencer failure, state validation, data availability, exit window and proposer failure. The site is built to be read, not exported: the risk grades are icons in a table and the value breakdown sits behind a hover. This Actor returns the whole board as rows, with the risk verdicts as structured data instead of colored squares.

| Who uses it | What they use the board for |
|---|---|
| 💼 Crypto funds and investors | Ranking chains by value secured and tracking where it moved over the last week |
| 🔍 Diligence teams on infrastructure deals | Checking a target chain's maturity stage and risk grades before committing |
| 🏗 Protocol and ecosystem teams | Benchmarking their own rollup against the stage and stack of every competitor |
| 📊 Researchers and analysts | Keeping a dated series of value secured per chain instead of screenshots |

### 📋 What it does

> 💡 **Why it matters:** two chains can report the same headline number and hold it very differently. One splits value into native, canonical and external, the other does not, and the risk grades say who can actually stop a withdrawal.

- 💰 **Returns the value secured, split four ways:** total, native, canonical and external, as numbers.
- 📈 **Includes the 7 day change** per project, positive or negative.
- 🎓 **Carries the maturity stage,** `Stage 0`, `Stage 1`, `Stage 2` or `Not applicable`, which is L2BEAT's judgement on how far decentralised a chain really is.
- 🛡 **Returns the five risk verdicts as structured rows,** each with its name, its value and whether L2BEAT rates it good, bad or in between.
- 🧱 **Names the stack and the host chain.** `providers` gives the framework, for example `OP Stack`, and `hostChain` gives what it settles to.
- 🔎 **Filters before it collects,** by layer type, rollup category, maturity stage, and whether archived projects are included.
- 💾 **Exports to CSV, Excel, JSON or XML**, from the run page or the API.

### 📊 Output

Every project is one flat row, with the same 20 fields on every run. Values are numbers, not formatted strings.

| Field | Type | Description |
|---|---|---|
| 🏷 `name` | string | Project name, for example `Arbitrum One` |
| 🔤 `slug` | string | L2BEAT's URL slug for the project |
| 🆔 `id` | string | L2BEAT's internal project id. Matches `slug` on most projects |
| 🧩 `type` | string | `layer2` or `layer3` |
| 📚 `category` | string | Rollup category, for example `Optimistic Rollup`, `ZK Rollup`, `Validium`, `Optimium` |
| 🎓 `stage` | string | Maturity stage, for example `Stage 1` |
| ⛓ `hostChain` | string | The chain it settles to, for example `Ethereum` |
| 🗄 `isArchived` | boolean | `true` if L2BEAT has archived the project |
| 🔬 `isUnderReview` | boolean | `true` if L2BEAT is currently reviewing the project's data |
| 🎯 `purposes` | array | What the chain is for, for example `["Universal"]` |
| 🏗 `providers` | array | Stack or framework, for example `["OP Stack"]` |
| 💰 `tvsTotal` | number | Total value secured |
| 🪙 `tvsNative` | number | The part issued natively on the chain |
| 🌉 `tvsCanonical` | number | The part bridged through the canonical bridge |
| 🔀 `tvsExternal` | number | The part bridged through external bridges |
| 📈 `tvsChange7d` | number | Change in value secured over 7 days, as a decimal fraction. Negative when it fell |
| 🛡 `riskSummary` | array | L2BEAT's five risk verdicts. Each entry has `name`, `value` and `sentiment` |
| 🔗 `l2beatUrl` | string | Link to the project page on l2beat.com |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |

#### Example rows

```json
{
  "name": "Base Chain",
  "slug": "base",
  "id": "base",
  "type": "layer2",
  "category": "Optimistic Rollup",
  "stage": "Stage 1",
  "hostChain": "Ethereum",
  "isArchived": false,
  "isUnderReview": false,
  "purposes": [
    "Universal"
  ],
  "providers": [
    "OP Stack"
  ],
  "tvsTotal": 14679392256,
  "tvsNative": 6922889659.96875,
  "tvsCanonical": 2762977991.3720617,
  "tvsExternal": 4993527184.634766,
  "tvsChange7d": 0.013784235259057587,
  "riskSummary": [
    {
      "name": "Sequencer Failure",
      "value": "Self sequence",
      "sentiment": "good"
    },
    {
      "name": "State Validation",
      "value": "Fraud proofs (1R, ZK)",
      "sentiment": "good"
    },
    {
      "name": "Data Availability",
      "value": "Onchain",
      "sentiment": "good"
    },
    {
      "name": "Exit Window",
      "value": "None",
      "sentiment": "bad"
    },
    {
      "name": "Proposer Failure",
      "value": "Self propose",
      "sentiment": "good"
    }
  ],
  "l2beatUrl": "https://l2beat.com/scaling/projects/base",
  "scrapedAt": "2026-09-14T16:36:03.749Z",
  "error": null
}
```

```json
{
  "name": "Arbitrum One",
  "slug": "arbitrum",
  "id": "arbitrum",
  "type": "layer2",
  "category": "Optimistic Rollup",
  "stage": "Stage 1",
  "hostChain": "Ethereum",
  "isArchived": false,
  "isUnderReview": false,
  "purposes": [
    "Universal"
  ],
  "providers": [
    "Arbitrum"
  ],
  "tvsTotal": 12137410560,
  "tvsNative": 4334244495.800781,
  "tvsCanonical": 3543731940.660411,
  "tvsExternal": 4259442638.6777573,
  "tvsChange7d": -0.04334964427890653,
  "riskSummary": [
    {
      "name": "Sequencer Failure",
      "value": "Self sequence",
      "sentiment": "good"
    },
    {
      "name": "State Validation",
      "value": "Fraud proofs (INT)",
      "sentiment": "good"
    },
    {
      "name": "Data Availability",
      "value": "Onchain",
      "sentiment": "good"
    },
    {
      "name": "Exit Window",
      "value": "None",
      "sentiment": "bad"
    },
    {
      "name": "Proposer Failure",
      "value": "Self propose",
      "sentiment": "good"
    }
  ],
  "l2beatUrl": "https://l2beat.com/scaling/projects/arbitrum",
  "scrapedAt": "2026-09-14T16:36:03.862Z",
  "error": null
}
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **Risk grades as data** | The five verdicts come back with a name, a value and a sentiment, so they can be sorted and filtered. |
| **The value breakdown, not one number** | Native, canonical and external are separate columns. |
| **Filters applied before the cap** | Narrow to ZK rollups at Stage 1 and `maxItems` counts only those. |
| **Archived projects are opt in** | Dead chains stay out of the dataset unless you ask for them. |
| **You pay per row** | No subscription. A filter that matches nothing costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Leave the filters empty for the whole board, or set `type`, `category` and `stage`.
4. Set `maxItems` to cap the run, and switch on `includeArchived` if you want retired projects.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run:

```json
{
  "maxItems": 10,
  "includeArchived": false
}
```

Only mature ZK rollups:

```json
{
  "type": "layer2",
  "category": "ZK Rollup",
  "stage": "Stage 1",
  "maxItems": 100,
  "includeArchived": false
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `maxItems` | No | Maximum rollups to collect in a run. Defaults to 10 |
| `type` | No | `layer2` or `layer3`. Empty includes every type |
| `category` | No | `Optimistic Rollup`, `ZK Rollup`, `Validium`, `Optimium` or `Other`. Empty includes every category |
| `stage` | No | `Stage 0`, `Stage 1`, `Stage 2` or `Not applicable`. Empty includes every stage |
| `includeArchived` | No | Include projects L2BEAT has archived. Off by default |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per project row | $0.01 | $0.00933 | $0.00867 | $0.008 | $0.008 | $0.008 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $1.00 |
| 1,000 | $10.00 |
| 10,000 | $100.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🤖 Use with an AI agent

Give an agent live access to the board over the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/l2beat-rollup-tvl-scraper"
```

Then ask it in plain language which Stage 1 rollups lost value this week and have it read the numbers back.

### ❓ Frequently asked questions

**What is the difference between `tvsNative`, `tvsCanonical` and `tvsExternal`?**
Native is value issued on the chain itself, canonical is value bridged through the chain's own bridge, and external is value bridged through a third party bridge. `tvsTotal` is the headline figure L2BEAT shows.

**How do I read `riskSummary`?**
It is a list of five entries. Each has a `name`, the verdict as `value`, and a `sentiment` that says how L2BEAT rates it. In CSV exports the list is flattened into columns by the exporter.

**Is `tvsChange7d` a percent?**
It is a decimal fraction over seven days, and it is negative when value fell. Multiply by 100 for a percentage.

**Why did I get fewer rows than `maxItems`?**
The filters narrow the board before the cap. A combination like `layer3` plus `Stage 2` matches very few projects.

**Do I need a proxy?**
No. Requests and retries are handled inside the Actor and included in the price.

**What can I export?**
CSV, Excel, JSON and XML from the run page, or JSON straight from the API.

### 🔗 More from Acquisition Automation Co.

- [BitMart Spot Markets Scraper](https://apify.com/acquistion-automation/bitmart-markets-scraper)
- [SEC Investor Alerts Scraper](https://apify.com/acquistion-automation/sec-investor-alerts-scraper)
- [FTC Actions Scraper](https://apify.com/acquistion-automation/ftc-actions-scraper)
- [404 Media Articles Scraper](https://apify.com/acquistion-automation/404media-articles-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by L2BEAT. It collects only publicly available data, and nothing here is investment advice. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of rollups to collect per run.

## `type` (type: `string`):

Filter projects by layer type. Leave empty to include every type.

## `category` (type: `string`):

Filter projects by rollup category. Leave empty to include every category.

## `stage` (type: `string`):

Filter projects by L2BEAT maturity stage. Leave empty to include every stage.

## `includeArchived` (type: `boolean`):

Include projects that L2BEAT has archived. Off by default.

## Actor input object example

```json
{
  "maxItems": 10,
  "type": "",
  "category": "",
  "stage": "",
  "includeArchived": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/l2beat-rollup-tvl-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/l2beat-rollup-tvl-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call acquistion-automation/l2beat-rollup-tvl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/l2beat-rollup-tvl-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/z4vlOkPC2iRfQikHD/builds/MKbW1lZrlldV7LahQ/openapi.json