Collectors · Finance & crypto

DeFiLlama API in Python

Total value locked per blockchain — DeFiLlama data, keyless. One POST from Python with the input, rows back as JSON with 9 fields, $0.0003 per delivered chain. No proxies or parsers to maintain.

Get an API key See the collector

A Python requests snippet that posts { — A Python requests call to the defillama collector returns one dict per chain, at $0.0003 each.

First call

Install, call, read the rows.

pip install requests

The only dependency.

import os, requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/defillama/run",
    headers={"Authorization": f"Bearer {os.environ['QD_API_KEY']}"},
    json={
        "max_results": 50,
    },
    timeout=120,
)
r.raise_for_status()
run = r.json()["payload"]
print(run["count"], "rows,", run["cost"]["usd"], "USD")
for row in run["results"]:
    print(row.get("chain"), row.get("tvl"), row.get("token_symbol"), row.get("chain_id"))

Python: one DeFi TVL (DeFiLlama) run (Top chain per TVL), printing chain, tvl, token_symbol, chain_id

The key comes from an environment variable, never from the code. The run answers in the same request when it finishes in time; payload.results holds the rows and payload.cost what they cost.

Request parameters

What the collector takes.

Input of the DeFi TVL (DeFiLlama) collector
Parameter	Type	Required	Meaning
`chains`	array	no	Filter to specific chains (Ethereum, Solana…). Empty = all, ranked by TVL.
`max_results`	integer	no (default 50)	How many chains to deliver at most (1–200). You pay only for delivered chains.

Response fields

9 fields per chain.

Fields of each row (chain)
Field	Type	What it holds
`rank`	integer	TVL rank.
`chain`	string	Blockchain name.
`tvl`	integer	Total value locked, USD.
`token_symbol`	string, nullable	Native token symbol.
`chain_id`	integer, nullable	EVM chain id when applicable.
`gecko_id`	string, nullable	CoinGecko id (join key).
`cmc_id`	string, nullable	CoinMarketCap id.
`tvl_rank`	integer	Rank by TVL across every chain, also on a filtered run.
`tvl_share_pct`	number, nullable	Share of the total TVL of all chains, %.

Add ?format=csv to the runs endpoint to get the same rows as CSV.

Long runs

Run in the background, then poll.

A run that needs more time can go to the background: send "async": true, get 202 with the run id, and poll the runs endpoint until the status is done. Reading a run is free.

import os, time, requests

H = {"Authorization": f"Bearer {os.environ['QD_API_KEY']}"}
r = requests.post("https://api.quanticdata.io/v1/scraper/collectors/defillama/run", headers=H,
                  json={**{"max_results":50}, "async": True}, timeout=30)
run_id = r.json()["payload"]["run_id"]
while True:
    run = requests.get(f"https://api.quanticdata.io/v1/scraper/collectors/runs/{run_id}", headers=H, timeout=30).json()["payload"]
    if run["status"] in ("done", "failed"):
        break
    time.sleep(5)
print(run["status"], run["count"])

Python: background run and polling

Errors

What can come back, and what is billed.

Collector run errors
Status	Meaning	Billed
`400`	The input does not match the collector (`payload.errors`)	No
`401`	Missing or wrong API key	No
`402`	Balance and free credit do not cover the run: top up	No
`422`	The input can never resolve; retrying the same input cannot help	No
`424`	The run failed at the source (blocked, timed out, layout changed); safe to retry	No
`429`	Rate limit or a per-account brake; wait for `Retry-After`	No

Only delivered rows are billed: a run that delivers nothing costs nothing.

Price

$0.0003 per delivered chain.

What DeFi TVL (DeFiLlama) rows cost at list price
Rows	Cost
1	$0.0003
1,000	$0.30
10,000	$3.00

Up to 200 chains per run; split larger jobs into several runs. The $2 free credit every month covers about 6,666 chains. No subscription; paid tiers lower the unit price. All collector prices: collector pricing.

Before you run it

Questions developers ask

Is there a free DeFi TVL (DeFiLlama) API?

Every account gets $2 of free usage each month, about 6,666 chains of this collector at $0.0003 each, with no card.

Do I have to handle proxies, retries or blocks?

No. The collector runs on our network and handles them; a run blocked at the source returns 424 and is not billed.

How many rows can one run return?

Up to 200 chains per run (the max_results input, where the collector has one).

Can an AI agent run it?

Yes: the MCP server exposes it as the run_collector tool, with the same input and price. See the MCP server.

Run it on the free credit.

Create an API key, export it as QD_API_KEY and run the example. $0.0003 per delivered chain, no subscription.

Get an API key DeFiLlama API