⛓️ 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

{
  "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)

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

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.