# DeFi TVL and Stablecoin Yield Monitor with Alerts (`transparent_meteorite/defi-protocol-tvl-yields-monitor`) Actor

Screen DeFi protocols by chain, category and TVL change, filter stablecoin yield pools by minimum TVL and APY, and get alerts when thresholds are crossed since your last run. Beta.

- **URL**: https://apify.com/transparent_meteorite/defi-protocol-tvl-yields-monitor.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## DeFi TVL + Stablecoin Yield Monitor with Alerts

Use this to screen DeFi protocols by TVL change and find stablecoin yield pools by TVL and APY, with alerts when thresholds are crossed.

**Beta. Data for research and monitoring only, not financial advice.** DeFi data can be wrong, delayed or manipulated; verify on the linked DefiLlama page before you act, and never rely on a single metric. Built on the free DefiLlama open API, local unit tests with recorded-shape fixtures, and a live check of both endpoints before release. Open an issue on the Issues tab if a field looks wrong and we fix it fast.

### What it does

Three modes in one actor, all from the **free public DefiLlama API** (no key, no login, no proxy):

1. **Protocol TVL list.** Filter protocols by chain, category, minimum TVL and 1-day / 7-day TVL change. Sort by TVL or change.
2. **Stablecoin yield pools.** Filter pools by chain, project, minimum pool TVL and APY range. DefiLlama outlier pools are excluded by default.
3. **Alerts vs last run.** Each run is compared with the snapshot saved in a named key-value store. You get one row per threshold crossed: protocol TVL fell or rose by X percent, a pool APY crossed above or below a level, a pool's TVL dropped, or a new pool now matches your filters. The first alerts run only saves a baseline and charges nothing. Runs where nothing crossed charge nothing.

### Use cases

- Daily watch on the protocols you hold or follow: get a row only when TVL moves sharply.
- Shortlist stablecoin pools above your APY and size thresholds for manual review.
- Feed a dashboard, spreadsheet or bot with clean JSON / CSV of DeFi TVL and yields.

### Example input

```json
{ "mode": "yields", "chains": ["Ethereum"], "minPoolTvlUsd": 5000000, "minApy": 4, "maxItems": 5 }
```

Alerts (schedule it daily on Apify):

```json
{ "mode": "alerts", "alertOn": "both", "minTvlUsd": 1000000000, "tvlDropPct": 10, "minApy": 3, "apyAbove": 6 }
```

### Output fields

Protocols: name, slug, category, chain(s), tvlUsd, change1hPct, change1dPct, change7dPct, mcapUsd, url, sourceUrl.
Pools: project, chain, symbol, tvlUsd, apy, apyBase, apyReward, apy change 1d / 7d, apyMean30d, stablecoin, ilRisk, exposure, sourceUrl.
Alerts add: alert (type), previousTvlUsd or previousApy, changeSinceLastRunPct, threshold, previousRunAt, alertedAt.

### Pricing

Pay per event: $0.002 per record returned (about $2 per 1,000). Actor start $0.00005. Baseline runs and runs with no alerts return nothing and charge nothing. Set Maximum cost per run to cap spend.

### Data source, limits and attribution

Data: DefiLlama (defillama.com) free open API, `api.llama.fi/protocols` and `yields.llama.fi/pools`. Every row links to its DefiLlama page. This actor is independent and not affiliated with or endorsed by DefiLlama. Values refresh on DefiLlama's own schedule (roughly every 30 minutes), so alerts reflect the data at run time. APYs are variable and can be temporary. Pools flagged stablecoin by DefiLlama can still carry smart-contract, depeg and counterparty risk.

### Output sample

Each result is one dataset item (JSON, CSV, Excel or via API). Shape taken from the actor's dataset schema; field names and meanings below, not live data:

| Field | Meaning |
|---|---|
| `alert` |  |
| `type` |  |
| `name` |  |
| `project` |  |
| `chain` |  |
| `symbol` |  |
| `tvlUsd` |  |
| `change1dPct` |  |
| `change7dPct` |  |
| `apy` |  |
| `changeSinceLastRunPct` |  |
| `sourceUrl` |  |

### FAQ

**How do I try it quickly?** Press Start with the prefilled input; it is a small run.

**How is it priced?** Pay per event; see the Pricing section above or the Pricing tab. A small run costs very little.

**Is this a one-off or can it run on a schedule?** Both. Use Apify schedules or the API to run it repeatedly.

**What if the source is slow or fails?** Failed or rate-limited requests (HTTP 429 or 5xx, network errors) are retried up to 4 attempts with growing waits; if a source stays unavailable the run records a warning instead of returning invented results.

**Is the data legal to use?** The actor reads public data. You are responsible for using the results in line with applicable law and the source's terms.

### Alternatives to DeFi TVL and Stablecoin Yield Monitor with Alerts

Other ways to get similar data, so you can choose what fits:

- **DefiLlama website and API**: the free source this actor reads
- **Dune**: SQL analytics on blockchain data
- **Token Terminal**: paid protocol fundamentals

This actor's edge is pay-per-result pricing, no login and ready-to-use structured output. Compare on a small test run before you commit.

### Changelog

- **0.2** (2026-10-28): listing refresh (title, description, README sections, console prefills). No change to output fields.
- Earlier: initial release.

# Actor input Schema

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

Protocol TVL list, yield pool list, or alerts (compares to the previous run saved in a key-value store; the first alerts run only saves a baseline and is free).

## `chains` (type: `array`):

Keep only these chains, e.g. Ethereum, Arbitrum, Solana (case-insensitive). Empty = all chains.

## `categories` (type: `array`):

Protocols only. e.g. Lending, Dexs, Liquid Staking, Bridge. Empty = all.

## `protocols` (type: `array`):

Protocols only. DefiLlama slugs or names, e.g. aave-v3, lido. Empty = all.

## `minTvlUsd` (type: `integer`):

Protocols only. Drop protocols with total value locked below this.

## `minChange1dPct` (type: `integer`):

Protocols only. e.g. 10 keeps protocols whose TVL rose 10% or more in a day.

## `maxChange1dPct` (type: `integer`):

Protocols only. e.g. -10 keeps protocols whose TVL fell 10% or more in a day.

## `minChange7dPct` (type: `integer`):

Protocols only.

## `maxChange7dPct` (type: `integer`):

Protocols only.

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

Protocols only.

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

Cap on rows delivered (and charged) this run.

## `stablecoinOnly` (type: `boolean`):

Keep only pools DefiLlama flags as stablecoin pools.

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

Drop thin pools below this TVL.

## `minApy` (type: `integer`):

Keep pools with APY at or above this.

## `maxApy` (type: `integer`):

Drop extreme APYs, which are often short-lived or very risky.

## `projects` (type: `array`):

Pools only. DefiLlama project names, e.g. aave-v3, morpho-blue. Empty = all.

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

Pools only.

## `excludeOutliers` (type: `boolean`):

Drop pools DefiLlama flags as statistical outliers.

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

Applies to protocol and pool lists.

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

Which side to compare. Uses the filters above to decide what is watched.

## `tvlDropPct` (type: `integer`):

Versus the previous run.

## `tvlRisePct` (type: `integer`):

Versus the previous run. 0 = off.

## `apyAbove` (type: `integer`):

Fires when a pool goes from below to at/above this APY since the previous run. 0 = off.

## `apyBelow` (type: `integer`):

Fires when a pool goes from above to at/below this APY. 0 = off.

## `poolTvlDropPct` (type: `integer`):

Versus the previous run. 0 = off.

## `flagNewPools` (type: `boolean`):

Flag pools that match your filters now but were not in the previous run.

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

Named key-value store holding the last-run snapshot. Change it to keep separate monitors or to reset the baseline.

## Actor input object example

```json
{
  "mode": "protocols",
  "chains": [
    "Ethereum"
  ],
  "minTvlUsd": 1000000000,
  "protocolSortBy": "tvl",
  "maxItems": 5,
  "stablecoinOnly": true,
  "minPoolTvlUsd": 1000000,
  "minApy": 3,
  "maxApy": 100,
  "poolSortBy": "apy",
  "excludeOutliers": true,
  "order": "desc",
  "alertOn": "both",
  "tvlDropPct": 10,
  "tvlRisePct": 0,
  "apyAbove": 0,
  "apyBelow": 0,
  "poolTvlDropPct": 0,
  "flagNewPools": false,
  "stateStoreName": "defi-monitor-state"
}
```

# Actor output Schema

## `overview` (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 = {
    "chains": [
        "Ethereum"
    ],
    "minTvlUsd": 1000000000,
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/defi-protocol-tvl-yields-monitor").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 = {
    "chains": ["Ethereum"],
    "minTvlUsd": 1000000000,
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/defi-protocol-tvl-yields-monitor").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 '{
  "chains": [
    "Ethereum"
  ],
  "minTvlUsd": 1000000000,
  "maxItems": 5
}' |
apify call transparent_meteorite/defi-protocol-tvl-yields-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/defi-protocol-tvl-yields-monitor"
        }
    }
}
```

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/ksCgH9bO9Kyj50LOy/builds/dQ60Ap5jsjYJObbxn/openapi.json