# 💸 DeFi Yields & Lending Rates Tracker (`nexgendata/defi-yields-lending-rates`) Actor DeFi yields and lending rates across 15k+ pools (DefiLlama): APY (base + reward), TVL, 30d mean APY, IL risk, stablecoin flag — by chain and protocol. For yield farmers, crypto treasuries, and aggregators. - **URL**: https://apify.com/nexgendata/defi-yields-lending-rates.md - **Developed by:** [NexGenData](https://apify.com/nexgendata) (community) - **Categories:** Business - **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $20.00 / 1,000 tranco rank lookup per domains 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 Yields & Lending Rates Tracker **One call returns the entire on-chain yield surface — 15,000+ pools across every major chain and protocol, with base vs. reward APY, TVL, and risk flags — at $0.10 per pool record. No DeFiLlama Pro subscription, no DeBank seat, no per-API-key rate-limit wall.** ### Overview DeFi yield is hopelessly fragmented. Lending markets live on Aave and Compound, concentrated-liquidity pools on Uniswap v3/v4 and Curve, liquid staking on Lido and Rocket Pool, auto-compounding vaults on Yearn and Convex, and a long tail of newer farms chasing TVL with reward emissions. Each protocol exposes its own API, its own APY math, and its own field names — so building any cross-protocol view means writing and maintaining a dozen brittle integrations, then reconciling them into a single schema before you can even start analyzing. This actor collapses that work into a single request. It reads the aggregated yields dataset behind **DefiLlama** — the most widely used open data layer in DeFi — covering 15,000+ pools across Ethereum, Solana, Arbitrum, Base, Optimism, Polygon, BNB Chain, Avalanche, and dozens more. You filter by chain, protocol, symbol, or minimum TVL, choose a sort field, and get back a clean, JSON-native snapshot of where capital can be deployed and what it earns. Crucially, every pool ships with the fields you need to tell *sustainable* yield from *mercenary* yield: the split between `apyBase` (organic, fee-driven yield) and `apyReward` (incentive emissions), a 30-day mean APY to smooth spikes, an impermanent-loss flag, a stablecoin flag, and an asset-exposure descriptor. Whether you are a treasury manager hunting stablecoin yield above a TVL threshold, a quant backtesting a rotation strategy, or a researcher mapping liquidity flows, this turns the sprawling yield landscape into one structured feed you query in a single call. ### Why use this - **One call, the whole yield surface.** Instead of integrating Aave, Curve, Yearn, and the rest individually and reconciling formats, you get every pool in one consistent schema sourced from DefiLlama's aggregation. - **Risk-aware fields out of the box.** Each record carries `ilRisk` (impermanent-loss exposure), `stablecoin` (is it a stable pool), `exposure` (single vs. multi-asset), and the `apyBase` / `apyReward` split — so a 6% organic yield is never confused with a 6% propped up by emissions. - **Filter and sort server-side.** Pass `minTvlUsd` to drop dust pools, narrow by `chain`, `project`, or `symbol`, and `sortBy` your preferred metric before a single record reaches your code. - **Pay only for what you pull.** Pricing is per result — a targeted query costs a few cents, not a four-figure annual seat. - **JSON-native, automation-ready.** Flat dataset built for pipelines, notebooks, dashboards, and spreadsheets — no HTML scraping, no PDF parsing. - **Every pool links back to source.** Each record includes a `defillamaUrl` so an analyst can verify any number in one click. ### What you get Each pool is returned as a flat JSON object. The fields: | Field | Type | Description | |---|---|---| | `chain` | string | The blockchain the pool lives on (e.g. `Ethereum`, `Solana`, `Arbitrum`). | | `project` | string | The protocol / project slug (e.g. `uniswap-v4`, `aave-v3`, `lido`). | | `symbol` | string | The pool's token symbol or pair (e.g. `WBTC-USDT`, `USDC`, `STETH`). | | `tvlUsd` | number | Total value locked in the pool, in USD. | | `apy` | number | Headline annual percentage yield (total: base + reward), as a percent. | | `apyBase` | number | Organic, fee/interest-driven APY excluding incentive emissions. | | `apyReward` | number \| null | APY from incentive/reward token emissions; `null` when there are none. | | `apyMean30d` | number | 30-day mean APY — a smoothed view that filters short-lived spikes. | | `ilRisk` | string | Impermanent-loss risk flag (`yes` / `no`). | | `stablecoin` | boolean | `true` if the pool is composed of stablecoins. | | `exposure` | string | Asset exposure: `single` (one asset) or `multi` (multi-asset / LP). | | `poolId` | string | DefiLlama's stable unique identifier for the pool. | | `rewardTokens` | array \| null | Reward token contract addresses, when applicable; `null` otherwise. | | `defillamaUrl` | string | Direct link to the pool's page on DefiLlama for verification. | The combination of `apy`, `apyBase`, `apyReward`, and `apyMean30d` is what makes the dataset useful for diligence: a high headline `apy` with a small `apyBase` and a far lower `apyMean30d` signals emissions reverting to the mean — exactly what a treasury or risk team needs before committing capital. ### Use cases - **Yield aggregators and routers.** Power an "best yield for asset X above $Y TVL" engine without maintaining per-protocol integrations. - **DeFi funds and asset managers.** Screen the entire opportunity set daily, rank by risk-adjusted yield, and feed allocation models. - **DAO and corporate treasury managers.** Find the highest stablecoin yield that clears a minimum TVL safety threshold and carries acceptable IL risk. - **Quantitative researchers.** Pull periodic snapshots to build time series for yield-rotation, mean-reversion, and emissions-decay backtests. - **Dashboards and analytics products.** Drive yield tables, heatmaps, and chain-vs-chain comparisons from one JSON feed. - **Risk and diligence teams.** Flag pools where headline APY diverges sharply from `apyBase` and `apyMean30d`, or where IL exposure is high. - **Market researchers and journalists.** Map where TVL and yield concentrate across chains and protocols at any point in time. - **Protocol and competitive intelligence.** Benchmark your own pools' APY and TVL against comparable pools on rival protocols. ### Sample output ```json { "chain": "Ethereum", "project": "uniswap-v4", "symbol": "WBTC-USDT", "tvlUsd": 10650012, "apy": 83.11706, "apyBase": 83.11706, "apyReward": null, "apyMean30d": 6.67192, "ilRisk": "yes", "stablecoin": false, "exposure": "multi", "poolId": "b94bc69c-5304-4460-a993-abb62faeded6", "rewardTokens": null, "defillamaUrl": "https://defillama.com/yields/pool/b94bc69c-5304-4460-a993-abb62faeded6" } ```` This record is a textbook diligence example: a headline `apy` of ~83% that is entirely base yield (`apyReward` is `null`) but whose `apyMean30d` is only ~6.67% — the 83% is a transient fee spike, not a durable rate. The `ilRisk: "yes"` and `exposure: "multi"` flags confirm a volatile-pair LP position. ### Input parameters | Parameter | Type | Default | Required | Description | |---|---|---|---|---| | `chain` | string | — | No | Filter by chain (e.g. `Ethereum`, `Solana`). | | `project` | string | — | No | Filter by protocol / project. | | `symbol` | string | — | No | Filter by pool symbol (e.g. `USDC`). | | `minTvlUsd` | integer | — | No | Minimum pool TVL in USD; pools below this are excluded. | | `sortBy` | string | `apy` | No | Sort field. One of `apy`, `tvlUsd`, `apyBase`, `apyMean30d`. | | `maxResults` | integer | `1000` | No | Maximum number of pools to return. | All parameters are optional. With no input, the actor returns the top pools sorted by `apy` up to the default `maxResults`. Combine filters to scope tightly — for example, `chain: "Ethereum"`, `symbol: "USDC"`, `minTvlUsd: 1000000`, `sortBy: "apyMean30d"` returns large, established USDC pools on Ethereum ranked by their smoothed 30-day yield. ### How to use it #### Python (apify-client) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run_input = { "chain": "Ethereum", "symbol": "USDC", "minTvlUsd": 1000000, "sortBy": "apyMean30d", "maxResults": 50, } run = client.actor("YOUR_USERNAME/defi-yields-lending").call(run_input=run_input) for pool in client.dataset(run["defaultDatasetId"]).iterate_items(): print( f"{pool['project']:18} {pool['symbol']:14} " f"TVL ${pool['tvlUsd']:>14,.0f} " f"APY {pool['apy']:.2f}% base {pool['apyBase']:.2f}% 30d {pool['apyMean30d']:.2f}%" ) ``` #### cURL (run-sync-get-dataset-items) ```bash curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~defi-yields-lending/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "chain": "Ethereum", "symbol": "USDC", "minTvlUsd": 1000000, "sortBy": "apyMean30d", "maxResults": 50 }' ``` The `run-sync-get-dataset-items` endpoint runs the actor and returns the dataset rows in the same HTTP response — ideal for on-demand lookups, scheduled jobs, and serverless functions. Swap `YOUR_USERNAME`, `YOUR_APIFY_TOKEN`, and the input fields for your own. ### Pricing This actor is priced on a **pay-per-result** basis: **$0.10 per pool record returned.** There is no monthly minimum, no subscription, and no platform fee beyond what you consume. Worked examples: | Query | Records returned | Cost | |---|---|---| | Top 50 Ethereum USDC pools | 50 | **$5.00** | | Daily snapshot of 200 large pools | 200 | **$20.00** | | Full broad pull (`maxResults` 1,000) | 1,000 | **$100.00** | | Single targeted lookup (10 pools) | 10 | **$1.00** | Because billing is per result, filter tightly with `chain`, `project`, `symbol`, and `minTvlUsd`, and cap `maxResults` to what you need. A focused treasury screen returning 30 stablecoin pools costs **$3.00** — versus a four-figure annual seat on a platform you may use only occasionally. ### How this compares to DeFiLlama Pro / DeBank / Token Terminal | | This actor | DeFiLlama Pro | DeBank | Token Terminal | |---|---|---|---|---| | Pricing model | Pay per result ($0.10) | Monthly subscription | API plan / credits | Enterprise subscription | | Commitment | None — pay as you go | Recurring | Recurring | Annual contract | | Output | Flat JSON dataset, automation-ready | API + dashboard | API + app | Dashboard + API | | Best for | On-demand, scoped yield pulls | Heavy continuous API use | Wallet / portfolio tracking | Protocol financials | | Setup | One actor call | API key + plan | API key + plan | Sales process | This actor does not replace a full analytics subscription for a team hitting the API thousands of times a day — for that volume, a flat-rate plan is cheaper. Its advantage is **scoped, no-commitment access**: when you need a clean yield snapshot for a screen, backtest input, dashboard refresh, or one-off diligence pass, you pay cents to dollars and get exactly the rows you asked for, in JSON, with no contract. ### FAQ **How fresh is the data?** Each run pulls the current state of DefiLlama's aggregated yields dataset at the moment you call the actor, so you always get the latest available snapshot. For ongoing monitoring, schedule the actor (for example, daily) and store each snapshot to build your own time series. **Which chains and protocols are covered?** Every chain and protocol present in DefiLlama's yields dataset — Ethereum, Solana, Arbitrum, Base, Optimism, Polygon, BNB Chain, Avalanche, and dozens more, across lending markets, DEX liquidity pools, liquid staking, and vaults. Use the `chain` and `project` filters to scope to what you need. **What's the difference between base APY and reward APY?** `apyBase` is the organic yield a pool generates from its own activity — trading fees for an LP, interest for a lending market. `apyReward` is additional yield paid in incentive tokens (emissions). `apy` is the sum. Reward APY is often promotional and can disappear; base APY is the more durable signal, and `apyMean30d` shows how the total has actually behaved over the past month. **Is TVL included?** Yes. Every record carries `tvlUsd`, the pool's total value locked in USD. Use `minTvlUsd` to exclude small or illiquid pools, and `sortBy: "tvlUsd"` to rank by size. **Can I find only stablecoin pools?** Each record includes a `stablecoin` boolean you can filter on after retrieval, and you can combine `symbol` (e.g. `USDC`) with `minTvlUsd` at query time to scope to large stable pools. The `ilRisk` flag further helps confirm a pool carries no impermanent-loss exposure. **How do I assess risk on a pool?** Look at three fields together: `ilRisk` (impermanent-loss exposure), `exposure` (`single` vs. `multi`-asset), and the gap between `apy`, `apyBase`, and `apyMean30d`. A high headline `apy` with a low `apyMean30d` signals a transient spike rather than a sustainable rate. **How do I verify a specific number?** Every record includes `defillamaUrl`, a direct link to that pool's page on DefiLlama, so any analyst can confirm a figure in one click. ### Schema stability & versioning The output fields documented above — `chain`, `project`, `symbol`, `tvlUsd`, `apy`, `apyBase`, `apyReward`, `apyMean30d`, `ilRisk`, `stablecoin`, `exposure`, `poolId`, `rewardTokens`, and `defillamaUrl` — are the stable contract for this actor. New fields may be added over time, but existing field names and types will not be renamed or repurposed without a version bump and a note in the changelog. Build integrations against field names rather than positional assumptions, and treat `apyReward` and `rewardTokens` as nullable. The input schema (`schemaVersion: 1`) follows the same policy: additive changes only within a major version. ### Compliance & legal This actor returns **public, aggregated market data** describing on-chain DeFi pools, sourced from DefiLlama's openly published yields dataset. It does not access private accounts, wallets, or credentials, and it collects no personal data. The data is provided **for informational purposes only and does not constitute financial, investment, tax, or legal advice, nor a recommendation to enter any position.** DeFi yields are volatile, reward emissions can change or end without notice, and pools carry smart-contract, liquidity, and impermanent-loss risk. APY figures are estimates and may differ from amounts realized. Always conduct your own research and consult a qualified professional before deploying capital. Users are responsible for complying with applicable laws in their jurisdiction and with the terms of the underlying data source. ### Related actors Pair this with the rest of the NexGenData on-chain data suite: - **DefiLlama Protocol Fees & Revenue** — track the fees and revenue protocols actually generate, to validate whether a yield is backed by real economic activity. - **DefiLlama Chain TVL Rankings** — see where total value locked is concentrating across chains, for top-down allocation and trend analysis. - **Crypto & DeFi MCP** — a Model Context Protocol server that brings crypto and DeFi data directly into your AI agents and assistants. Together these turn fragmented on-chain data into a single, pay-per-use, JSON-native toolkit for yield discovery, risk screening, and DeFi research. # Actor input Schema ## `chain` (type: `string`): Filter by chain (e.g. Ethereum, Solana). ## `project` (type: `string`): Filter by protocol/project. ## `symbol` (type: `string`): Filter by pool symbol (e.g. USDC). ## `minTvlUsd` (type: `integer`): Minimum pool TVL. ## `sortBy` (type: `string`): Sort field. ## `maxResults` (type: `integer`): Max pools. ## Actor input object example ```json { "sortBy": "apy", "maxResults": 1000 } ``` # 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 = {}; // Run the Actor and wait for it to finish const run = await client.actor("nexgendata/defi-yields-lending-rates").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 = {} # Run the Actor and wait for it to finish run = client.actor("nexgendata/defi-yields-lending-rates").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 '{}' | apify call nexgendata/defi-yields-lending-rates --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=nexgendata/defi-yields-lending-rates", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "💸 DeFi Yields & Lending Rates Tracker", "description": "DeFi yields and lending rates across 15k+ pools (DefiLlama): APY (base + reward), TVL, 30d mean APY, IL risk, stablecoin flag — by chain and protocol. For yield farmers, crypto treasuries, and aggregators.", "version": "0.0", "x-build-id": "1WbPPj7ys0594EVvz" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/nexgendata~defi-yields-lending-rates/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-nexgendata-defi-yields-lending-rates", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/nexgendata~defi-yields-lending-rates/runs": { "post": { "operationId": "runs-sync-nexgendata-defi-yields-lending-rates", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/nexgendata~defi-yields-lending-rates/run-sync": { "post": { "operationId": "run-sync-nexgendata-defi-yields-lending-rates", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "chain": { "title": "Chain", "type": "string", "description": "Filter by chain (e.g. Ethereum, Solana)." }, "project": { "title": "Project", "type": "string", "description": "Filter by protocol/project." }, "symbol": { "title": "Symbol", "type": "string", "description": "Filter by pool symbol (e.g. USDC)." }, "minTvlUsd": { "title": "Min TVL (USD)", "type": "integer", "description": "Minimum pool TVL." }, "sortBy": { "title": "Sort by", "enum": [ "apy", "tvlUsd", "apyBase", "apyMean30d" ], "type": "string", "description": "Sort field.", "default": "apy" }, "maxResults": { "title": "Max results", "type": "integer", "description": "Max pools.", "default": 1000 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```