# ⛓️ DefiLlama Chain TVL Rankings (`nexgendata/defillama-chain-tvl-rankings`) Actor DeFi total value locked (TVL) ranked across 450+ blockchains (DefiLlama): chain name, TVL, native token, chain ID. For crypto analysts comparing chain ecosystems. - **URL**: https://apify.com/nexgendata/defillama-chain-tvl-rankings.md - **Developed by:** [NexGenData](https://apify.com/nexgendata) (community) - **Categories:** Business - **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $10.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. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## ⛓️ DefiLlama Chain TVL Rankings **Every blockchain DefiLlama tracks, ranked by total value locked — rank, chain name, TVL in USD, native token symbol, chain ID, and CoinGecko ID — delivered as clean, pay-per-result JSON. No Nansen seat, no Messari Pro contract, no DefiLlama Pro API tier.** ### What this actor does The DefiLlama Chain TVL Rankings actor turns DefiLlama's chains dataset into a clean, ranked, filterable feed. For every Layer-1 and Layer-2 that DefiLlama covers — from Ethereum, Solana, and Tron down the long tail past 450 chains — you get the chain's current DeFi total value locked, its position in the league table, its native token symbol, its numeric chain ID, its CoinGecko `geckoId` for downstream price joins, and a direct link to the chain's DefiLlama page. Filter by name, set a minimum TVL floor to drop dust chains, cap your result count, and pull exactly the slice of the multi-chain landscape your analysis needs. Total value locked is the single most-cited headline metric in DeFi. It is the proxy for how much capital an ecosystem has attracted, and the denominator behind market-share charts, bridge-flow analysis, and chain-rotation theses. When an analyst asks "is Solana gaining ground on Ethereum?", the answer starts with a ranked TVL table. This actor puts that authoritative table at your fingertips as a scriptable feed. DefiLlama is the reference source for cross-chain TVL, and the underlying data is free and open. What it is not is *convenient* for a pipeline: the chains data arrives through endpoints whose shape and identifier fields shift as chains are added and renamed, with no ranked, filtered export tuned for a warehouse load or a notebook. This actor does the normalization for you — it computes the rank, attaches the joins-ready identifiers, and hands you a flat array of records you can drop straight into pandas, a spreadsheet, or a SQL table. ### Why use this - **Ranked out of the box.** Every record carries a `rank` field computed from current TVL, so the league table is already sorted — no client-side ordering, no tie-breaking logic to maintain. - **Joins-ready identifiers.** Each chain ships with both its numeric EVM `chainId` and its CoinGecko `geckoId`, so you can join TVL against on-chain RPC data on one side and price/market-cap feeds on the other. - **Filter before you pay.** Set `minTvlUsd` to cut out dust chains, `nameContains` to grab a specific ecosystem, and `maxResults` to cap the run. You only pull — and only pay for — the rows you actually need. - **No subscription.** No annual analytics-platform contract, no per-seat licensing, no Pro API tier. You pay per result, on demand. - **Pipeline-native output.** A flat JSON array with stable field names, ready for a notebook, a dashboard backend, or a scheduled warehouse load. - **Authoritative source.** Built on DefiLlama, the dataset that the rest of the industry quotes when it talks about chain TVL. ### What you get Each item in the output dataset is one blockchain. The fields are: | Field | Type | Description | |-------|------|-------------| | `rank` | integer | The chain's position in the TVL league table, where 1 is the chain with the highest total value locked. | | `name` | string | The chain name as DefiLlama labels it (e.g. `Ethereum`, `Solana`, `Tron`). | | `tvlUsd` | number | Current total value locked on the chain, expressed in US dollars. This is a full-precision float, not a rounded display value. | | `tokenSymbol` | string | The ticker of the chain's native/gas token (e.g. `ETH`, `SOL`). May be empty for chains DefiLlama does not map to a single native token. | | `chainId` | integer | The numeric EVM chain ID (e.g. `1` for Ethereum). Use this to join against RPC data, wallet configs, and bridge tables. May be absent for non-EVM chains that have no canonical numeric ID. | | `geckoId` | string | The CoinGecko identifier for the chain's native token (e.g. `ethereum`). Use this to join against price, market-cap, and volume feeds. | | `defillamaUrl` | string | A direct link to the chain's page on DefiLlama for manual verification and drill-down. | ### Use cases - **L1 / L2 ecosystem researchers** — pull the full ranked table to track how liquidity is distributed across Layer-1s and rollups, and how that distribution shifts over time. - **Crypto funds and trading desks** — feed TVL rankings into chain-rotation models, screen for ecosystems gaining capital, and size positions against where liquidity actually sits. - **Ecosystem and BD teams** — benchmark your chain against peers, build the "we rank #N by TVL" slide, and identify the chains worth integrating with or bridging to. - **Dashboards and data products** — power a live TVL leaderboard or a chain-comparison widget without standing up your own DefiLlama ingestion. - **Market-share analysis** — compute each chain's share of total DeFi TVL, the concentration of the multi-chain landscape, or the Ethereum-vs-rest ratio that anchors many ecosystem theses. - **Journalists and analysts** — ground a story or a research note in the authoritative ranked figures, with a `defillamaUrl` to cite and verify against. ### Sample output ```json { "rank": 1, "name": "Ethereum", "tvlUsd": 36815534914.711716, "tokenSymbol": "ETH", "chainId": 1, "geckoId": "ethereum", "defillamaUrl": "https://defillama.com/chain/Ethereum" } ```` A run returns a JSON array of these records, ranked from highest TVL to lowest, after your filters are applied. ### Input parameters | Parameter | Title | Type | Default | Description | |-----------|-------|------|---------|-------------| | `nameContains` | Name contains | string | — | Filter to chains whose name contains this substring. Leave empty to include all chains. | | `minTvlUsd` | Min TVL (USD) | integer | — | Minimum chain TVL in USD. Chains below this floor are excluded — useful for dropping dust chains. | | `maxResults` | Max results | integer | `1000` | Maximum number of chains to return. Caps the run so you only pull (and pay for) what you need. | None of the parameters are required. With no input, the actor returns the full ranked table up to the `maxResults` default of 1000. ### How to use it #### Python (apify-client) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run_input = { "minTvlUsd": 100000000, # only chains with >= $100M TVL "maxResults": 50, } run = client.actor("YOUR_USERNAME/defillama-chain-tvl").call(run_input=run_input) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(f"#{item['rank']:>3} {item['name']:<16} ${item['tvlUsd']:,.0f}") ``` #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~defillama-chain-tvl/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "minTvlUsd": 100000000, "maxResults": 50 }' ``` Both calls return the dataset items directly. Swap `YOUR_APIFY_TOKEN` for your Apify API token and `YOUR_USERNAME` for the actor owner's username. ### Pricing This actor is priced at **$0.10 per result** — one result being one chain returned in the dataset. You control the bill with the input filters. Because `minTvlUsd` and `maxResults` cut rows *before* they are returned, you only pay for the chains you actually pull. Worked examples: - **Top 20 chains** (`maxResults: 20`): 20 results × $0.10 = **$2.00** - **All chains above $100M TVL** (roughly several dozen, depending on the day): say 60 results × $0.10 = **$6.00** - **The full long-tail table** (450+ chains, `maxResults: 1000`, no floor): ~460 results × $0.10 = **~$46.00** For most workflows — a leaderboard, a fund screen, a research note — you want the top tier of chains, where a run costs a few dollars. There is no subscription, no minimum, and no charge when a run returns zero results. ### How this compares to DefiLlama Pro / L2Beat | | This actor | DefiLlama Pro API | L2Beat / analytics platforms | |---|---|---|---| | **Pricing model** | Pay per result, on demand | Recurring subscription / API tier | Recurring subscription or seat | | **Output** | Flat, ranked JSON array | Raw API JSON you normalize yourself | Dashboards built for the browser | | **Ranking** | Pre-computed `rank` field | Compute it yourself | Visual, not export-tuned | | **Filtering** | Built in (`nameContains`, `minTvlUsd`, `maxResults`) | Query and post-process yourself | Limited / UI-driven | | **Commitment** | None — run when you need it | Ongoing | Ongoing | DefiLlama Pro and analytics platforms like L2Beat are excellent for interactive exploration. This actor is for the other case: when you want the ranked table as a *scriptable feed* — for a one-off analysis, a scheduled job, or a data product — without a recurring tier. It is JSON-native, pay-per-use, and tuned for pipelines rather than browsing. (DefiLlama remains the upstream source; this actor packages its open data for programmatic use.) ### FAQ **How fresh is the data?** Each run fetches the current chains dataset from DefiLlama at request time, so the TVL figures and rankings reflect DefiLlama's latest published values when you run the actor. There is no cached snapshot served between runs. **How many chains does it cover?** Every chain DefiLlama tracks — over 450 at the time of writing — from the largest Layer-1s down the long tail. Use `maxResults` to cap how many you receive and `minTvlUsd` to focus on chains above a size threshold. **What does TVL include?** `tvlUsd` is DefiLlama's measure of the total value locked in DeFi protocols on that chain, denominated in USD. It follows DefiLlama's methodology — broadly, assets deposited in the DeFi protocols DefiLlama indexes for that chain. It is not the chain's total market cap or the value of all bridged assets; it is the DeFi capital DefiLlama attributes to the chain. **How is `rank` computed?** Rank is assigned by current `tvlUsd` in descending order across the full chain set: the chain with the highest TVL is rank 1, the next is rank 2, and so on. Rank is computed over all tracked chains, then your filters are applied — so if you filter, the `rank` values you see still reflect each chain's true position in the overall table. **What are `chainId` and `geckoId` for?** `chainId` is the numeric EVM chain ID, for joining against RPC endpoints, wallet configs, and bridge tables. `geckoId` is the CoinGecko identifier for the native token, for joining against price and market-cap feeds. Together they let you enrich TVL with both on-chain and market data. **Why might `chainId` or `tokenSymbol` be empty?** Not every chain has a canonical numeric chain ID (many non-EVM chains do not), and not every chain maps cleanly to a single native token in DefiLlama's data. Where DefiLlama does not provide a value, the field is left empty or absent rather than populated with a guess. **Can I get just one ecosystem?** Yes. Set `nameContains` to a substring of the chain name (for example, an ecosystem keyword) to return only matching chains, and combine it with `minTvlUsd` and `maxResults` as needed. ### Schema stability & versioning The output fields documented here — `rank`, `name`, `tvlUsd`, `tokenSymbol`, `chainId`, `geckoId`, and `defillamaUrl` — are the stable contract for this actor. New fields may be added over time, but existing field names and meanings are kept backward-compatible so your pipelines do not break on an update. Because the data originates upstream at DefiLlama, individual values (TVL, rank, and occasionally a chain's name) change as the market and DefiLlama's coverage change; the *shape* of each record does not. If a breaking change ever becomes necessary, it will be communicated in the actor's changelog before release. We recommend reading fields by name and tolerating occasionally empty `chainId` / `tokenSymbol` values, as described in the FAQ. ### Compliance & legal This actor returns public market data — total-value-locked figures and chain metadata sourced from DefiLlama, which publishes this information openly. It collects no personal data and accesses nothing behind authentication. The output is provided **for informational purposes only and is not investment, financial, trading, or legal advice.** TVL figures and rankings are estimates produced by DefiLlama's methodology and can be revised, delayed, or incomplete; you should independently verify any figure before relying on it for a decision. Cryptocurrency markets are volatile and high-risk. Nothing here is a recommendation to buy, sell, or hold any asset. You are responsible for complying with DefiLlama's terms and with the laws and regulations applicable to your use of the data. DefiLlama, CoinGecko, L2Beat, Nansen, and Messari are trademarks of their respective owners; this actor is independent and not affiliated with or endorsed by any of them. ### Related actors If you are building a broader DeFi data stack, these companion actors from the same publisher pair naturally with chain TVL rankings: - **DefiLlama Protocol Fees & Revenue** — go a layer deeper than TVL: track the fees and revenue individual protocols actually generate, to see which ecosystems produce real economic activity, not just locked capital. - **DeFi Yields & Lending Rates** — pull current yield and lending-rate data across pools and chains, to pair "where is the capital" (TVL) with "what is it earning." - **Crypto & DeFi MCP** — a Model Context Protocol server that exposes crypto and DeFi data to LLM agents, so you can query TVL, fees, and yields conversationally inside an AI workflow. Together these let you move from the high-level chain league table down to protocol economics, yields, and agent-ready access — all on the same pay-per-result model. # Actor input Schema ## `nameContains` (type: `string`): Filter by chain name. ## `minTvlUsd` (type: `integer`): Minimum chain TVL. ## `maxResults` (type: `integer`): Max chains. ## Actor input object example ```json { "maxResults": 1000 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("nexgendata/defillama-chain-tvl-rankings").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("nexgendata/defillama-chain-tvl-rankings").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{}' | apify call nexgendata/defillama-chain-tvl-rankings --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=nexgendata/defillama-chain-tvl-rankings", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "⛓️ DefiLlama Chain TVL Rankings", "description": "DeFi total value locked (TVL) ranked across 450+ blockchains (DefiLlama): chain name, TVL, native token, chain ID. For crypto analysts comparing chain ecosystems.", "version": "0.0", "x-build-id": "czCmCOMWWYqHqzDAw" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/nexgendata~defillama-chain-tvl-rankings/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-nexgendata-defillama-chain-tvl-rankings", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/nexgendata~defillama-chain-tvl-rankings/runs": { "post": { "operationId": "runs-sync-nexgendata-defillama-chain-tvl-rankings", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/nexgendata~defillama-chain-tvl-rankings/run-sync": { "post": { "operationId": "run-sync-nexgendata-defillama-chain-tvl-rankings", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "nameContains": { "title": "Name contains", "type": "string", "description": "Filter by chain name." }, "minTvlUsd": { "title": "Min TVL (USD)", "type": "integer", "description": "Minimum chain TVL." }, "maxResults": { "title": "Max results", "type": "integer", "description": "Max chains.", "default": 1000 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```