# DeFi TVL, Yields & Stablecoin Tracker (`scrapemint/defi-tvl-tracker`) Actor

Total value locked by protocol and chain, pool yields ranked by APY, and stablecoin supply with growth, all from DefiLlama. Compare where the money is and what it earns. No API key.

- **URL**: https://apify.com/scrapemint/defi-tvl-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## DeFi TVL, Yields & Stablecoin Tracker

Track where money sits in DeFi and what it earns, straight from [DefiLlama](https://defillama.com). No API key, no wallet, no login.

Four modes, one clean row shape each:

| Mode | What you get | Ranked by |
| --- | --- | --- |
| **Protocols by TVL** | Every protocol's total value locked, with 1h / 1d / 7d change, category, chains and market cap | TVL |
| **Pool yields by APY** | Liquidity pools with base + reward APY, TVL, impermanent-loss risk and APY trend | APY |
| **Chains by TVL** | Total value locked per blockchain | TVL |
| **Stablecoins by supply** | Circulating supply per stablecoin with 1d / 7d / 30d growth and current price | Supply |

### Inputs

| Field | Applies to | Meaning |
| --- | --- | --- |
| `mode` | all | `protocols` (default), `yields`, `chains`, `stablecoins` |
| `chain` | protocols, yields | One chain, e.g. `Ethereum`, `Solana`, `Base`, `Arbitrum`. Blank = all |
| `category` | protocols | One DefiLlama category, e.g. `Lending`, `Dexs`, `Liquid Staking` |
| `project` | yields | One project slug, e.g. `aave-v3`, `lido`, `uniswap-v3` |
| `stablecoinPoolsOnly` | yields | Only pools whose assets are stablecoins |
| `minPoolTvlUsd` | yields | Drop pools below this TVL before ranking (default $1,000,000) |
| `includeOutlierPools` | yields | Include pools DefiLlama flags as APY outliers (off by default) |
| `includeCex` | protocols | Include centralized-exchange reserves (off by default) |
| `maxResults` | all | How many rows to return, highest first (default 50) |

#### Why the pool TVL floor defaults high

The single highest APYs on DefiLlama are almost always tiny, illiquid or short-lived incentive-farmed pools, not places you can actually park size. So `yields` mode drops pools under $1,000,000 TVL by default before ranking. Lower `minPoolTvlUsd` if you specifically want the long tail.

### Notes on the data

- All figures are live reads from DefiLlama's public endpoints. `change_*` and `apyPct*` fields are percentages already.
- Protocols with no live TVL (delisted, pre-launch, accounting artifacts) are dropped, so counts are smaller than DefiLlama's raw listing total.
- Centralized-exchange reserves (Binance, OKX) are excluded from `protocols` mode by default, since this is a DeFi tracker; set `includeCex` to add them.
- Pools DefiLlama flags as APY outliers (short-lived reward farming) are excluded from `yields` by default; set `includeOutlierPools` to add them, flagged with `outlierApy`.
- APY is not a promise. Reward APY in particular depends on token incentives that can end at any time.

### Pricing

Pay per row returned. The first 2 rows of every run are free so you can check the shape before committing a full pull. Runs that match nothing are not charged.

# Actor input Schema

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

protocols = TVL leaderboard by protocol. yields = liquidity pools ranked by APY. chains = TVL by blockchain. stablecoins = stablecoin supply and growth.

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

Limit to one blockchain, e.g. Ethereum, Solana, Base, Arbitrum. Leave blank for all chains. Applies to protocols and yields modes.

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

Limit protocols to one DefiLlama category, e.g. Lending, Dexs, Liquid Staking, Derivatives, CDP. Leave blank for all.

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

Limit pools to one project slug, e.g. aave-v3, lido, uniswap-v3. Leave blank for all projects.

## `stablecoinPoolsOnly` (type: `boolean`):

Only return pools whose assets are stablecoins. Useful for low-risk yield screening.

## `minPoolTvlUsd` (type: `integer`):

Drop pools below this TVL before ranking by APY. Kept high by default because the highest APYs are almost always tiny, illiquid or incentive-farmed pools rather than places you can actually park size.

## `includeOutlierPools` (type: `boolean`):

DefiLlama flags pools whose APY is a statistical outlier (short-lived reward farming, e.g. 76,000%). They are dropped by default so the ranking reflects yields you could realistically hold. Turn on to see them, flagged with outlierApy.

## `includeCex` (type: `boolean`):

DefiLlama lists centralized-exchange reserves (Binance, OKX) as protocols. They are excluded by default because this is a DeFi tracker and they dwarf real DeFi TVL. Turn on to include them.

## `maxResults` (type: `integer`):

How many rows to return, highest first (TVL for protocols/chains/stablecoins, APY for yields).

## Actor input object example

```json
{
  "mode": "protocols",
  "stablecoinPoolsOnly": false,
  "minPoolTvlUsd": 1000000,
  "includeOutlierPools": false,
  "includeCex": false,
  "maxResults": 50
}
```

# 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 = {
    "mode": "protocols",
    "chain": "",
    "category": "",
    "project": "",
    "minPoolTvlUsd": 1000000,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/defi-tvl-tracker").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 = {
    "mode": "protocols",
    "chain": "",
    "category": "",
    "project": "",
    "minPoolTvlUsd": 1000000,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/defi-tvl-tracker").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 '{
  "mode": "protocols",
  "chain": "",
  "category": "",
  "project": "",
  "minPoolTvlUsd": 1000000,
  "maxResults": 50
}' |
apify call scrapemint/defi-tvl-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/defi-tvl-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/rUAafHjDKBgcdDo3k/builds/v2EXnF51er9tKSjkd/openapi.json