Stablecoins Monitor — Supply, Peg Health & Depeg (DefiLlama)

Every stablecoin's circulating supply, growth and peg health — in one exportable table. This Actor turns DefiLlama's public stablecoins API into clean, flat rows: 380+ stablecoins with circulating supply, 1d/7d/30d growth, current price, peg deviation (the depeg signal), peg type & mechanism, dominant chain and chain count — ranked and filterable, ready for a sheet, dashboard or risk model.

Built on DefiLlama's free, public data — no API key, no login, no proxy — so it's cheap to run and easy to schedule into a daily "supply & depeg" feed.

• 🪙 380+ stablecoins — the whole DefiLlama universe (USD, EUR, GBP, JPY…), not a sample
• 📉 Depeg signal built in — absolute % off the $1 peg for every USD-pegged coin, sortable worst-first
• 🧮 Yield-accruing coins don't fake a depeg — USDY, USYC, reUSD & co. are designed to trade above $1, so they're detected and kept out of the depeg metric instead of topping your alert list (how)
• 📊 Supply + growth — circulating supply with 1d/7d/30d change, dominant chain and chain count
• ⚡ Two requests → one flat dataset (JSON / CSV / Excel / API) — no key, no proxy, schedulable

Quick start (API)

Get the 100 biggest USD stablecoins by circulating supply, in one call:

curl -X POST "https://api.apify.com/v2/acts/foxlabs~stablecoins-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "pegType": "peggedUSD", "minCirculating": 1000000, "sortBy": "circulating", "maxResults": 100 }'

Prefer no code? Open the Input tab, adjust the filters, and click Start — then download the results.

What you get

One clean, flat record per stablecoin:

Field	Type	Description
rank	integer	Position in the returned, sorted list (1 = top by your sortBy)
name	string	Stablecoin name (e.g. Tether)
symbol	string	Ticker (e.g. USDT)
pegType	string	What it targets — peggedUSD, peggedEUR, peggedGBP, peggedJPY…
pegMechanism	string	How the peg is held — fiat-backed, crypto-backed or algorithmic
pegBehavior	string	How the coin is meant to price: fiat-pegged (targets its peg), yield-accruing (NAV rises above $1 by design), variable-peg (floating target, DefiLlama peggedVAR), or unknown (no price to judge)
pegBehaviorSource	string	Evidence behind pegBehavior — upstream:yieldBearing, price-history:90d, upstream:pegType or curated-fallback. Audit the call yourself
price	number | null	Current price in the peg currency (USD-pegged target = 1.0); null if source has no price
pegDeviationPct	number | null	The depeg signal. Absolute % away from the $1 peg. null for non-USD pegs and for yield-accruing coins, whose premium is earned yield, not a broken peg
priceVsOneUsd	number | null	Raw, never suppressed. Signed % vs $1 (+ = premium) for every USD-pegged coin, including yield-accruing ones. Use this for return/NAV maths
depegAlert	boolean	true only when pegBehavior is fiat-pegged and pegDeviationPct ≥ 1% — the field to wire straight into an alert
circulating	number	Circulating supply in USD (raw)
circulatingCompact	string	Human-readable supply (e.g. $184.10B)
change1dPct	number | null	24-hour change in circulating supply (%)
change7dPct	number | null	7-day change in circulating supply (%)
change30dPct	number | null	30-day change in circulating supply (%)
dominantChain	string	Chain holding the largest share of supply
chainCount	integer	Number of chains the coin is issued on
topChainsText	string	Up to the top 5 chains by supply, comma-separated
geckoId	string	CoinGecko id, for cross-referencing/enrichment
source	string	Provenance — always DefiLlama
generatedAtIso	string	ISO-8601 timestamp of when the row was produced

Sample output

Example row (illustrative — live values change every run):

{
  "rank": 1,
  "name": "Tether",
  "symbol": "USDT",
  "pegType": "peggedUSD",
  "pegMechanism": "fiat-backed",
  "pegBehavior": "fiat-pegged",
  "pegBehaviorSource": "price-history:90d",
  "price": 0.9989713990080804,
  "pegDeviationPct": 0.1,
  "priceVsOneUsd": -0.1,
  "depegAlert": false,
  "circulating": 183920824314.11673,
  "circulatingCompact": "$183.92B",
  "change1dPct": -0.19,
  "change7dPct": -0.04,
  "change30dPct": -0.57,
  "dominantChain": "Tron",
  "chainCount": 130,
  "topChainsText": "Tron, Ethereum, BSC, Solana, Arbitrum",
  "geckoId": "tether",
  "source": "DefiLlama",
  "generatedAtIso": "2026-07-27T22:23:14.424Z"
}

And a yield-accruing coin — note pegDeviationPct: null (it is not off peg) while the raw priceVsOneUsd: 13.45 is still there for your own maths:

{
  "name": "Ondo US Dollar Yield",
  "symbol": "USDY",
  "pegType": "peggedUSD",
  "pegMechanism": "fiat-backed",
  "pegBehavior": "yield-accruing",
  "pegBehaviorSource": "upstream:yieldBearing",
  "price": 1.1344947511195258,
  "pegDeviationPct": null,
  "priceVsOneUsd": 13.45,
  "depegAlert": false,
  "circulating": 2139859385.8305807,
  "circulatingCompact": "$2.14B",
  "dominantChain": "Ethereum",
  "geckoId": "ondo-us-dollar-yield",
  "source": "DefiLlama"
}

Yield-accruing coins are not depegs

A growing share of "stablecoins" are yield-bearing: they don't hold $1 at all, their price ratchets upward as yield accrues (a NAV, like a money-market share). USDY sits near $1.13, USYC near $1.13, reUSD near $1.09 — all perfectly healthy, all working exactly as designed.

A naive |price − 1| calls those the most broken stablecoins on the market. On a treasury-sized depeg watch (minCirculating: 100000000, minPegDeviation: 1) that meant 3 of 4 alerts were false, and the one genuine break — apxUSD at −13% on $295M — was buried between them. This Actor fixes that:

• pegBehavior classifies every coin, upstream-first: DefiLlama's own yieldBearing flag; then a 90-day price-history test — a coin that never came within 2% of $1 all window, drifted up and barely drew down is a NAV ratchet, not a broken peg; then a tiny curated id list as a fallback only when history is missing. pegBehaviorSource tells you which rule fired.
• pegDeviationPct is null for yield-accruing coins, so they can't top a sortBy: pegDeviation ranking, can't match minPegDeviation, and can't raise depegAlert.
• priceVsOneUsd keeps the raw number — nothing is hidden, it just stops masquerading as a depeg.

Crucially this is not "big deviation ⇒ ignore it". A coin that really was at $1 and fell keeps $1 inside its price history, so it stays flagged — downside breaks (apxUSD −13%, MIM −92%) and genuinely broken above-$1 coins (HAI +27%, HEXDC +27%, which drift down and draw down hard) all remain alerts.

Input & filters

• Peg type — target currency: peggedUSD, peggedEUR, peggedGBP, peggedJPY… Leave empty for all.
• Peg mechanism — fiat-backed, crypto-backed or algorithmic. Leave empty for all.
• Min circulating supply (USD) — drop dust and dead coins (e.g. 1000000 = at least $1M).
• Min peg deviation (%) — depeg hunt: keep only USD stablecoins at least this far off $1 (try 1).
• Chain — keep only coins issued on a chain (Ethereum, Tron, Solana, BSC…). Leave empty for all.
• Sort by — circulating supply, peg deviation (most depegged first) or 7-day growth.
• Max results — cap the rows returned. The universe is ~388, but you can request up to 100,000.

Example inputs (copy & paste)

// 1) Supply leaderboard: biggest USD stablecoins over $1M
{ "pegType": "peggedUSD", "minCirculating": 1000000, "sortBy": "circulating", "maxResults": 100 }

// 2) Depeg watch: USD coins more than 1% off $1, worst first
{ "minPegDeviation": 1, "sortBy": "pegDeviation" }

// 2b) Treasury depeg watch: only breaks that matter — $100M+ supply, 1%+ off peg
{ "minCirculating": 100000000, "minPegDeviation": 1, "sortBy": "pegDeviation" }

// 3) Algorithmic stablecoins on Ethereum, fastest 7-day growth first
{ "pegMechanism": "algorithmic", "chain": "Ethereum", "sortBy": "change7d" }

// 4) Fiat-backed stablecoins ranked by circulating supply
{ "pegMechanism": "fiat-backed", "sortBy": "circulating", "maxResults": 100 }

// 5) Euro (EUR) stablecoins by supply
{ "pegType": "peggedEUR", "sortBy": "circulating" }

// 6) Stablecoins issued on Tron, biggest first
{ "chain": "Tron", "sortBy": "circulating", "maxResults": 100 }

// 7) Crypto-backed stablecoins by 7-day growth
{ "pegMechanism": "crypto-backed", "sortBy": "change7d" }

// 8) Fastest-growing large stablecoins market-wide (>= $10M)
{ "minCirculating": 10000000, "sortBy": "change7d", "maxResults": 100 }

Use cases

• Depeg & risk monitoring. Schedule a daily run with minPegDeviation: 1 and sortBy: pegDeviation to surface coins drifting off $1 — often before the headlines do. Feed it into an alert (Slack/email via Make/Zapier) so a broken or collapsing peg reaches you fast. Yield-accruing coins are filtered out of that signal, so the alert stays quiet until something is actually wrong — wire it to depegAlert: true and you're done.
• Supply & market-share dashboards. Pull the full list sorted by circulating to chart who's biggest, who's growing (1d/7d/30d) and how supply concentrates across issuers — a live stablecoin market map into your BI tool.
• Research & market sizing. Studying the sector? Count coins by pegMechanism (fiat- vs crypto-backed vs algorithmic) or by pegType (USD, EUR, GBP…) to size each segment and track the shift over time with scheduled snapshots.
• Treasury & DeFi risk models. Rank the stablecoins you hold or accept by supply trend and current peg deviation, and watch dominantChain / chainCount for concentration risk — inputs for a collateral or counterparty risk score.
• Chain exposure analysis. Filter by chain to see which stablecoins (and how much supply) live on a given network — useful for L2/chain teams sizing on-chain dollar liquidity.
• Data enrichment. Each row carries geckoId and symbol, so you can join this feed to price, market-cap or on-chain datasets you already have.

Performance & throughput

Each run makes two HTTP requests to DefiLlama's public endpoints — the stablecoins list, plus 90 days of price history used to tell yield-accruing coins from real depegs — then filters and sorts locally, so a full pull of the ~410-coin universe completes in seconds. The history request is best-effort: if it's slow or down the run still finishes, falling back to DefiLlama's yieldBearing flag plus a curated id list, and logs a warning. There are no external keys, proxies or rate limits; throughput is bounded only by your Apify plan. maxResults accepts up to 100,000, but the current universe is ~410 coins, so most runs return the whole (filtered) list well under that cap.

Integrations

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/stablecoins-monitor').call({
  pegType: 'peggedUSD', minCirculating: 1000000, sortBy: 'circulating', maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

Python (apify-client):

from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/stablecoins-monitor").call(run_input={
    "pegType": "peggedUSD", "minCirculating": 1000000, "sortBy": "circulating", "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item.get("circulatingCompact"), item.get("pegDeviationPct"))

Also works with Make / n8n / Zapier (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the Apify MCP server so AI agents can pull a live stablecoin feed on demand.

Data quality

• Identity fields — name, symbol, pegType, pegMechanism, chains and supply come straight from DefiLlama and are present for essentially every asset.
• price / pegDeviationPct — price is null when DefiLlama publishes no price for a coin. pegDeviationPct is computed only for USD-pegged assets (target $1); for EUR/GBP/other pegs, and for yield-accruing coins, it's intentionally null. The raw distance from $1 is always in priceVsOneUsd.
• pegBehavior is a classification, not a fact from the source. DefiLlama's yieldBearing flag is authoritative but incomplete (it currently misses reUSD, Solayer sUSD and USP), so coins it doesn't flag are also judged on 90 days of price history. Coins with fewer than 30 days of history stay unclassified rather than guessed, and pegBehaviorSource always names the rule that fired so you can audit or override it.
• Growth fields — change1dPct / change7dPct / change30dPct are null when there's no prior-period figure (e.g. brand-new coins), never guessed.
• No fabrication. Every value is passed through or arithmetically derived from DefiLlama's data; missing inputs yield null, not a made-up number.

Pricing

The data source (DefiLlama's public stablecoins API) is free — no key, no proxy, no third-party cost — and each run is two requests, so compute stays minimal. You can evaluate the full feature set on Apify's free tier before scheduling it. Any Apify usage is billed by Apify under the Actor's listed plan.

FAQ

Do I need an API key or account? No. No key, no login, no proxy — the DefiLlama endpoint is public.

Where does the data come from? DefiLlama's public stablecoins API (stablecoins.llama.fi). Each run fetches the current data.

How fresh is it? It's live at run time. Schedule the Actor (e.g. daily) for a rolling supply & depeg feed.

What exactly is "peg deviation"? The absolute percentage distance of a coin's price from its $1 target. pegDeviationPct: 1 means the coin trades ~1% away from $1. It's computed for USD-pegged coins only, and only where $1 really is the target — see the next question.

Why is pegDeviationPct null for USDY / USYC / reUSD? Because they're yield-accruing: they're built to trade above $1 and rise as yield accrues, so calling them "13% depegged" is a false alarm. They're marked pegBehavior: "yield-accruing" and kept out of the depeg metric, while priceVsOneUsd still reports the raw premium. See Yield-accruing coins are not depegs.

Can I still treat a yield-accruing coin as depegged? Yes — priceVsOneUsd is never suppressed, so sort or filter on that instead and you get the old |price − 1| behaviour, with pegBehavior there to tell the two populations apart.

How do I hunt depegs? Set minPegDeviation (e.g. 1) and sortBy: pegDeviation — the most depegged USD coins come first, with yield-accruing coins excluded. For alerting, just filter rows where depegAlert is true.

Can I get non-USD stablecoins? Yes — leave pegType empty for all, or set peggedEUR, peggedGBP, peggedJPY, etc. Note that peg deviation is only measured for USD-pegged coins.

Which chains can I filter by? Any chain DefiLlama tracks — Ethereum, Tron, Solana, BSC, Arbitrum, Base, and many more.

Why is price or pegDeviationPct null for some coins? Either the coin isn't USD-pegged (so no deviation is computed) or DefiLlama has no price for it. That's the source, not a miss.

What export formats are available? JSON, CSV, Excel, or via the Apify API/integrations.

How many stablecoins are there? ~410 today; the Actor returns the full current list (subject to your filters and maxResults).

Troubleshooting

• 0 results → your filters are too narrow. Lower minCirculating, clear chain, or reduce minPegDeviation.
• Depeg run returns few or no rows → most stablecoins hold their peg, so a high minPegDeviation legitimately matches nothing. Lower the threshold (e.g. 0.5) or remove it to see the current spread.
• price / pegDeviationPct is null → the coin isn't USD-pegged, the source has no price, or the coin is yield-accruing (its premium isn't a depeg) — expected, not an error. priceVsOneUsd still carries the raw number.
• A coin you consider yield-bearing is still flagged as a depeg → it either has fewer than 30 days of price history, or its price actually fell/came near $1 in the last 90 days. Check pegBehaviorSource, and use priceVsOneUsd + pegBehavior to apply your own rule.
• A pegMechanism filter misses a coin → the mechanism label is passed through verbatim from DefiLlama and a few source records carry non-standard spellings. Leave pegMechanism empty to include everything.

Notes, limits & legal (honest)

• Source & attribution. Data comes from DefiLlama's public stablecoins API; each row is stamped source: "DefiLlama". Please credit DefiLlama when you redistribute.
• Peg deviation scope. pegDeviationPct is computed only for USD-pegged assets (target $1) whose target really is $1. Non-USD pegs and yield-accruing coins report price and priceVsOneUsd but not deviation.
• pegBehavior is our judgement, not DefiLlama's. Only upstream:yieldBearing and upstream:pegType come from the source; price-history:90d and curated-fallback are this Actor's own classification. It's transparent (pegBehaviorSource) and conservative (unclear coins stay unknown or fiat-pegged), but it's a heuristic — verify before relying on it for anything that moves money, and use priceVsOneUsd if you'd rather apply your own rule.
• As-reported. Supply, price and growth are as published by DefiLlama and can lag or differ from other aggregators or an issuer's own attestation.
• Not affiliated with DefiLlama or any stablecoin issuer; this Actor reads and reshapes their public data.
• Not financial advice. This is market/analytics data for informational purposes only — do your own research.

Support

Questions, a field you'd like added, or a custom build? Open the Issues tab on this Actor, or email info@foxlabs.com.tr. We reply fast.

If this Actor saves you time, a ⭐ review really helps.

Changelog

0.2.1 — 2026-07-27

• Yield-accruing coins no longer fake a depeg. Coins that are designed to trade above $1 (USDY ~+13%, USYC ~+13%, reUSD ~+9%, Solayer sUSD ~+11%…) were ranked as the market's worst depegs. On a $100M+ depeg watch that meant 3 of 4 alerts were false and the one real break (apxUSD, −13% on $295M) was buried among them; the same watch now returns exactly that one row.
• New pegBehavior (fiat-pegged / yield-accruing / variable-peg / unknown) + pegBehaviorSource, classified upstream-first: DefiLlama's yieldBearing flag, then a 90-day price-history ratchet test (catches the coins the flag misses), then a small curated id list used only as a fallback.
• pegDeviationPct is now null for yield-accruing coins, so they can't top sortBy: pegDeviation, match minPegDeviation or raise an alert. New priceVsOneUsd keeps the raw signed % vs $1 for every USD-pegged coin, and new depegAlert is a ready-to-wire boolean (fiat-pegged and ≥1% off peg).
• Genuine breaks are unaffected — downside depegs and broken above-$1 coins (HAI +27%, HEXDC +27%) still alert; USDT/USDC/DAI rows are unchanged.
• Adds a second, best-effort request (90d price history, 20s timeout): if it fails the run still completes on the upstream flag + curated list and logs a warning.

0.2 — 2026-07-05

• Gold-standard docs rework: API quick-start, full field table, real sample output, integration snippets (JS/Python/Make/MCP), FAQ, troubleshooting and honest data/legal notes. Polished input schema and metadata (SEO title, description, prefills).

0.1.1 — 2026-07-05

• Fixed a dataset-schema validation error that was silently returning zero results — the full stablecoin list is returned again.

0.1.0 — 2026-06-04

• Initial release: 380+ stablecoins from the free DefiLlama API — circulating supply, 1d/7d/30d growth, price, peg deviation (depeg), peg type & mechanism, dominant chain; filter by peg/mechanism/chain/min supply/min deviation; sort by supply, depeg or growth; flat CSV/Excel, no API key or proxy.

---

Part of the foXLabs data platform — a suite of public-data scrapers for company, contact, ownership, procurement, financial and AI-search intelligence. Browse the full suite at data.foxlabs.com.tr.