# DeFi Yield Pools Scraper (APY, TVL, IL Risk) (`scrapers_lat/defi-yield-pools-scraper`) Actor Scrape thousands of DeFi liquidity pools with live APY, base vs reward yield, TVL, 1D/7D/30D APY deltas, impermanent-loss risk and ML trend prediction. Filter by chain, protocol, token or stablecoin. Export to JSON, CSV or Excel. - **URL**: https://apify.com/scrapers\_lat/defi-yield-pools-scraper.md - **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community) - **Categories:** Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $11.34 / 1,000 yield pool records This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## 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 Yield Pools Scraper (APY, TVL, IL Risk)](https://scrapers.lat/banners/defi-yield-pools-scraper.png)](https://console.apify.com/actors/So00cIlon8Yxfu84c/input) ## DeFi Yield Pools Scraper (APY, TVL, IL Risk) Here is one real result, with every field the actor returns (the pool\_history and AI add-ons enabled): ```json { "chain": "Ethereum", "project": "lido", "symbol": "STETH", "poolId": "747c1d2a-c668-4682-b9f9-296708a3dd90", "poolMeta": null, "tvlUsd": 22760693591, "apy": 2.382, "apyBase": 2.382, "apyReward": null, "apyMean30d": 2.1932, "apyPct1D": 0.197, "apyPct7D": 0.182, "apyPct30D": 0.185, "rewardTokens": null, "stablecoin": false, "ilRisk": "no", "exposure": "single", "predictedClass": "Stable/Up", "predictedProbability": 74, "underlyingTokens": ["0x0000000000000000000000000000000000000000"], "volumeUsd1d": null, "volumeUsd7d": null, "poolUrl": "https://defillama.com/yields/pool/747c1d2a-c668-4682-b9f9-296708a3dd90", "historyPoints": 1542, "historyStart": "2022-05-03T00:00:00.000Z", "historyEnd": "2026-08-21T08:01:46.144Z", "apyAvgHist": 3.4477, "apyVolatility": 1.0517, "apyMinHist": 2.045, "apyMaxHist": 11.773, "tvlMinHist": 3874088251, "tvlMaxHist": 42441513059, "riskLevel": "Low", "sustainability": "The APY appears sustainable as it is entirely base yield with a stable trend.", "redFlags": null, "opportunityNote": "This pool suits conservative investors looking for stable returns.", "source": "defillama.com", "observedAt": "2026-08-21T08:26:26.566Z", "error": null } ``` The most complete DeFi yield scraper available. It returns every field the yields dataset exposes for each liquidity pool (chain, protocol, token symbol, TVL, total APY split into base and reward), plus the derived fields most scrapers skip: 1D/7D/30D APY deltas, impermanent-loss risk, asset exposure, an ML trend prediction, and optional per-pool history with computed APY volatility and an AI risk read. It scans thousands of pools across every chain and gives you eight filters to target exactly the yield you want. **📥 [Input](https://apify.com/scrapers_lat/defi-yield-pools-scraper/input-schema) · 📤 [Output](https://apify.com/scrapers_lat/defi-yield-pools-scraper/output-schema) · 💰 [Pricing](https://apify.com/scrapers_lat/defi-yield-pools-scraper/pricing) · ▶️ [Examples](https://apify.com/scrapers_lat/defi-yield-pools-scraper/examples)** ![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify\&logoColor=white) ![Coverage](https://img.shields.io/badge/Coverage-All%20chains%20%26%20protocols-blue) ![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange) ![Billing](https://img.shields.io/badge/Billing-Pay%20per%20result-brightgreen) ### Table of contents - [What it does](#what-it-does) - [Use cases](#use-cases) - [Quickstart](#quickstart) - [Input reference](#input-reference) - [Output reference](#output-reference) - [Example output record](#example-output-record) - [Run via API and CLI](#run-via-api-and-cli) - [Fetch results](#fetch-results) - [Billing and limits](#billing-and-limits) - [FAQ and troubleshooting](#faq-and-troubleshooting) ### What it does The actor scans the full DeFi yields universe (thousands of liquidity pools across every chain and protocol) and returns one clean record per pool that matches your filters. Each record carries the pool identity (chain, protocol, token symbol, pool id and link), the money numbers (TVL in USD, total APY, and the split into base APY from fees or lending and reward APY from token emissions), and the risk and trend signals that tell you whether a yield is real: the 1-day, 7-day and 30-day change in APY, the 30-day mean APY, an impermanent-loss risk flag, single or multi asset exposure, and a machine-learning prediction of where the APY is heading with a confidence score. You filter the set with eight controls: chain, protocol name, token symbol, minimum TVL, minimum and maximum APY, a stablecoin-only switch, and a sort by APY or TVL. Numbers are returned as plain numbers (for example `2.382` for `2.382%`, and `22760693591` for TVL), so nothing needs post-processing. Two optional add-ons deepen each record: a pool-history add-on that pulls the full APY and TVL time series and computes the average APY, APY volatility (standard deviation), and min and max APY and TVL over the pool's life, and an AI yield-risk add-on that reads the APY composition, IL risk and recent deltas to return a risk level, a sustainability verdict, concrete red flags and a one-line opportunity note. ### Use cases - **DeFi yield farming.** Rank the highest-APY pools on a chain or protocol, then use the base vs reward split and the APY deltas to tell durable yield from emissions that are already fading. - **APY monitoring.** Track how a pool's APY has moved over 1, 7 and 30 days, and with the history add-on measure its APY volatility so you can size positions to how stable the yield really is. - **Risk screening.** Filter out impermanent-loss pools, cap the maximum APY to skip unrealistic emission traps, require a minimum TVL to avoid illiquid pools, and add the AI risk read to surface red flags before you deposit. - **Stablecoin yield.** Flip the stablecoin-only switch to list lower-risk stablecoin pools and compare their yields across chains and protocols. - **Portfolio and treasury allocation.** Pull the top pools by TVL for the assets you hold and export the full set to a spreadsheet to plan allocations across chains. - **Analytics and dashboards.** Feed clean per-pool APY, TVL and trend data into your own dashboards, alerts or models on a schedule. ### Quickstart Open the actor, paste this into the input, and press Run. It returns the highest-APY Ethereum pools above one million dollars of TVL. ```json { "chain": "Ethereum", "minTvl": 1000000, "sort": "apy", "maxResults": 25 } ``` To list stablecoin USDC pools instead: ```json { "symbol": "USDC", "stablecoinOnly": true, "sort": "tvl", "maxResults": 25 } ``` ### Input reference | Field | Type | Required | Default | Description | |---|---|---|---|---| | `chain` | string | no | (all) | Filter to a single chain, matched exactly and case-insensitively, for example `Ethereum`, `Arbitrum`, `Solana`, `Base`, `Polygon`. | | `project` | string | no | (all) | Filter to protocols whose name contains this text, for example `aave`, `lido`, `uniswap`, `curve`, `pendle`. | | `symbol` | string | no | (all) | Filter to pools whose symbol contains this token, for example `USDC`, `ETH`, `WBTC`. Matches either side of a pair. | | `minTvl` | integer | no | (none) | Only return pools with at least this much TVL in USD, for example `1000000`. | | `minApy` | number | no | (none) | Only return pools with APY at or above this percent, for example `5`. | | `maxApy` | number | no | (none) | Only return pools with APY at or below this percent, for example `100`. Use to skip unrealistic emission APYs. | | `stablecoinOnly` | boolean | no | `false` | Return only pools flagged as stablecoin pools. | | `sort` | enum | no | `apy` | Sort matching pools before the cap. `apy` = highest APY first, `tvl` = largest TVL first. | | `includeHistory` | boolean | no | `false` | Paid add-on. Attach the APY and TVL time series plus derived average, volatility and min/max. Charged only when a series is returned. Disabled on free plans. | | `aiYieldRisk` | boolean | no | `false` | Paid add-on. Add an AI risk level, sustainability read, red flags and an opportunity note. Charged only when a usable analysis is returned. Disabled on free plans. | | `maxResults` | integer | no | `10` | Maximum pools to return across the run, after filtering and sorting. Free Apify plans are capped at 10 per run. | All filters are optional. With no filters the actor returns the top pools by APY. Filters combine, so setting several narrows the set. ### Output reference One dataset item per pool. Numeric fields are returned as numbers, or `null` when the source has no value. Percentages are plain numbers without the `%` sign. | Field | Type | Description | |---|---|---| | `chain` | string | Blockchain the pool is on. | | `project` | string | Protocol the pool belongs to. | | `symbol` | string | Token or pair symbol of the pool. | | `poolId` | string | DefiLlama pool identifier. | | `poolMeta` | string | Extra pool label or variant, for example a fee tier or lock period. | | `tvlUsd` | number | Total value locked in the pool, in USD. | | `apy` | number | Total net APY percent (base plus reward). | | `apyBase` | number | Base APY percent from trading fees or lending interest. | | `apyReward` | number | Reward APY percent from token emissions or incentives. | | `apyMean30d` | number | Mean APY percent over the last 30 days. | | `apyPct1D` | number | Change in APY over the last 1 day, in percentage points. | | `apyPct7D` | number | Change in APY over the last 7 days, in percentage points. | | `apyPct30D` | number | Change in APY over the last 30 days, in percentage points. | | `rewardTokens` | string\[] | Contract addresses of the reward tokens, or `null`. | | `stablecoin` | boolean | True if the pool is a stablecoin pool. | | `ilRisk` | string | Impermanent-loss risk flag, `yes` or `no`. | | `exposure` | string | Asset exposure, `single` or `multi`. | | `predictedClass` | string | ML prediction of the APY direction, for example `Stable/Up` or `Down`. | | `predictedProbability` | number | Confidence percent of the ML prediction. | | `underlyingTokens` | string\[] | Contract addresses of the underlying tokens, or `null`. | | `volumeUsd1d` | number | Trading volume over the last 1 day in USD, where available. | | `volumeUsd7d` | number | Trading volume over the last 7 days in USD, where available. | | `poolUrl` | string | Link to the pool page on DefiLlama. | | `historyPoints` | number | Number of history data points returned (history add-on). | | `historyStart` | string | First timestamp of the history series (history add-on). | | `historyEnd` | string | Last timestamp of the history series (history add-on). | | `apyAvgHist` | number | Average APY over the full history (history add-on). | | `apyVolatility` | number | Standard deviation of APY over the history (history add-on). | | `apyMinHist` | number | Minimum APY over the history (history add-on). | | `apyMaxHist` | number | Maximum APY over the history (history add-on). | | `tvlMinHist` | number | Minimum TVL over the history in USD (history add-on). | | `tvlMaxHist` | number | Maximum TVL over the history in USD (history add-on). | | `riskLevel` | string | AI risk level, Low to Very High (AI add-on). | | `sustainability` | string | AI read on whether the APY looks sustainable (AI add-on). | | `redFlags` | string\[] | AI-identified risk red flags (AI add-on), or `null`. | | `opportunityNote` | string | AI one-line opportunity note (AI add-on). | | `source` | string | Data source. | | `observedAt` | string | ISO 8601 timestamp when the record was collected. | | `error` | string | `null` on success. When no pool matches the filters, a single item with a populated `error` field is written and not charged. | ### Example output record Real stablecoin pool from a live run (input `{"symbol":"USDC","stablecoinOnly":true,"maxResults":3}`), add-ons off: ```json { "chain": "Avalanche", "project": "blackhole-clmm", "symbol": "REUSD-USDC", "poolId": "8f169a34-dabc-46a3-b0fe-58e75a337611", "poolMeta": "CL - 1", "tvlUsd": 11067, "apy": 1563.4824, "apyBase": 0, "apyReward": 1563.4824, "apyMean30d": 80.0565, "apyPct7D": 1558.2495, "apyPct30D": 1558.6127, "rewardTokens": ["0xcd94a87696FAC69Edae3a70fE5725307Ae1c43f6"], "stablecoin": true, "ilRisk": "no", "exposure": "multi", "predictedClass": "Down", "predictedProbability": 93, "poolUrl": "https://defillama.com/yields/pool/8f169a34-dabc-46a3-b0fe-58e75a337611", "source": "defillama.com", "observedAt": "2026-08-21T08:25:40.641Z", "error": null } ``` Note how `apyBase` is `0` and all of the APY is `apyReward`, with a `Down` ML prediction: a reward-driven yield the deltas already flag as fading. ### Run via API and CLI Start a run and read the dataset. Replace `` with your Apify API token. Run synchronously and get dataset items in one call: ```bash curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~defi-yield-pools-scraper/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{"chain":"Ethereum","minTvl":1000000,"sort":"apy","maxResults":25}' ``` Start a run asynchronously: ```bash curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~defi-yield-pools-scraper/runs?token=" \ -H "Content-Type: application/json" \ -d '{"symbol":"USDC","stablecoinOnly":true,"sort":"tvl","maxResults":50}' ``` Apify CLI: ```bash apify call scrapers_lat/defi-yield-pools-scraper \ --input '{"project":"lido","includeHistory":true,"aiYieldRisk":true}' ``` ### Fetch results Every run writes to a dataset. Fetch items as JSON, CSV, or Excel by changing `format`: ```bash ## JSON curl "https://api.apify.com/v2/datasets//items?token=&clean=true&format=json" ## CSV curl "https://api.apify.com/v2/datasets//items?token=&clean=true&format=csv" ## Paginate large datasets curl "https://api.apify.com/v2/datasets//items?token=&offset=1000&limit=1000" ``` `` is returned as `defaultDatasetId` in the run object. Use `offset` and `limit` to page through large result sets. `clean=true` drops empty and internal fields. ### Billing and limits - **Pay per result.** You are charged per pool returned (`result` event), plus a small one-time `apify-actor-start` event per run. See the [pricing tab](https://apify.com/scrapers_lat/defi-yield-pools-scraper/pricing) for current prices. - **Pool history add-on.** `includeHistory` is off by default. It fetches the pool's APY and TVL time series and computes volatility and averages. Charged (`pool_history` event) only when a real series is returned. - **AI yield-risk add-on.** `aiYieldRisk` is off by default. Charged (`ai_yield_risk` event) only when the AI returns a usable risk analysis. - **No charge on failure.** When no pool matches your filters, a single item with a populated `error` field is written and nothing is charged. Empty runs cost nothing. - **Add-ons disabled on free plans.** Both add-ons run only for paying users, since they add extra fetch and AI cost. - **Spend cap respected.** Set `maxTotalChargeUsd` on the run; once reached, the actor stops emitting and charging further results. - **Free Apify plans** are capped at 10 records per run. Upgrade for higher `maxResults`. ### FAQ and troubleshooting **A run returned a single item with an `error` field. Why?** No pool matched your filters. Loosen the chain, protocol, symbol, or the TVL and APY bounds. That row is not charged. **Are percentages returned with a `%` sign?** No. APY and delta metrics are plain numbers, so `2.382%` becomes `2.382`. TVL is returned as a full USD number. **What is the difference between `apyBase` and `apyReward`?** `apyBase` is the organic yield from trading fees or lending interest. `apyReward` is yield paid in incentive tokens, which can stop at any time. A high `apyReward` with a falling `apyPct7D` is a classic sign of a fading emission. **What is `predictedClass`?** A machine-learning prediction of where the pool's APY is heading (for example `Stable/Up` or `Down`), with `predictedProbability` as the confidence percent. **What does the history add-on add?** The full APY and TVL time series for the pool, plus the number of points, the start and end timestamps, the average APY, the APY volatility (standard deviation), and the minimum and maximum APY and TVL over the pool's life. **Does this need a login or an API key?** No. You never provide any credentials. Proxy and retries are handled internally. **Is this an official DefiLlama tool?** No. This actor is independent and has no affiliation with DefiLlama. It reads only data that is publicly available. ### Related scrapers - [DefiLlama Protocols Scraper](https://apify.com/scrapers_lat/defillama-protocols-scraper): protocol-level TVL, chains and category across DeFi. - [Finviz Stocks Scraper](https://apify.com/scrapers_lat/finviz-stocks-scraper): stock fundamentals, screener, insider trades and news. - [FRED Economic Data Scraper](https://apify.com/scrapers_lat/fred-economic-data-scraper): US and global economic time series. ### More scrapers at scrapers.lat Built and maintained by [scrapers.lat](https://scrapers.lat), where we publish scrapers for public platforms: company registries, government data, finance, web3, e-commerce and more. Browse the catalog or request a custom scraper at [scrapers.lat](https://scrapers.lat). *** > Independent tool, not affiliated with DefiLlama. Accesses only publicly available data. # Actor input Schema ## `chain` (type: `string`): Filter to a single blockchain, matched exactly (case-insensitive), e.g. Ethereum, Arbitrum, Solana, Base, Polygon, Optimism. Leave empty for all chains. ## `project` (type: `string`): Filter to protocols whose name contains this text, e.g. aave, lido, uniswap, curve, pendle. Leave empty for all protocols. ## `symbol` (type: `string`): Filter to pools whose symbol contains this token, e.g. USDC, ETH, WBTC, DAI. Matches either side of a pair. Leave empty for all symbols. ## `minTvl` (type: `integer`): Only return pools with at least this much total value locked, in USD. Use to skip tiny illiquid pools, e.g. 1000000. ## `minApy` (type: `number`): Only return pools with APY at or above this percentage, e.g. 5 for 5%. ## `maxApy` (type: `number`): Only return pools with APY at or below this percentage. Use to filter out unrealistic emission-driven APYs, e.g. 100. ## `stablecoinOnly` (type: `boolean`): Return only pools flagged as stablecoin pools (both sides are stablecoins). Useful for lower-risk yield. ## `sort` (type: `string`): Sort matching pools before applying the result cap. apy = highest APY first. tvl = largest TVL first. ## `includeHistory` (type: `boolean`): Attach the APY and TVL time series for each pool plus derived average APY, APY volatility, min/max APY and min/max TVL. Charged only when a real history series is returned. Disabled on free plans. ## `aiYieldRisk` (type: `boolean`): Use AI to add a risk level, yield sustainability read, red flags and an opportunity note from the APY composition, IL risk and recent deltas. Charged only when a usable analysis is returned. Disabled on free plans. ## `maxResults` (type: `integer`): Maximum number of yield pools to return across the run, after filtering and sorting. Free Apify plans are capped at 10 per run. ## Actor input object example ```json { "stablecoinOnly": false, "sort": "apy", "includeHistory": false, "aiYieldRisk": false, "maxResults": 10 } ``` # Actor output Schema ## `results` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "maxResults": 10 }; // Run the Actor and wait for it to finish const run = await client.actor("scrapers_lat/defi-yield-pools-scraper").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 = { "maxResults": 10 } # Run the Actor and wait for it to finish run = client.actor("scrapers_lat/defi-yield-pools-scraper").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 '{ "maxResults": 10 }' | apify call scrapers_lat/defi-yield-pools-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/defi-yield-pools-scraper" } } } ``` 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 ` 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/So00cIlon8Yxfu84c/builds/4crMQ028TnOqubwoJ/openapi.json