# Stablecoin Depeg Monitor: Supply, Price & Peg Alerts (`mrdoe/stablecoin-depeg-monitor`) Actor

Check USDT, USDC, DAI and more for depegs: price vs 1 USD, deviation %, supply by chain and 24h/7d/30d supply change, with a second price source to confirm. Alert-ready, no key.

- **URL**: https://apify.com/mrdoe/stablecoin-depeg-monitor.md
- **Developed by:** [MrDoe](https://apify.com/mrdoe) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 stablecoin row returneds

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

![Stablecoin Depeg Monitor: Supply, Price & Peg Alerts - Stablecoin depeg monitor showing price deviation, depeg flag and circulating supply by chain](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/stablecoin-depeg-monitor--hero.png)

### What does Stablecoin Depeg Monitor: Supply, Price & Peg Alerts do?

Stablecoin Depeg Monitor returns, for each USD-pegged stablecoin you choose, the current price, the deviation from the 1 USD peg in percent, a depeg flag against a threshold you set (0.5% by default) and the circulating supply in total and on the largest chains, with the supply change over 24 hours, 7 days and 30 days. Every price is cross-checked against a second source, and the row says whether the second source confirms the depeg. Schedule it every few minutes with delta mode or only-depegged to get an alert feed.

### Why use Stablecoin Depeg Monitor: Supply, Price & Peg Alerts?

- Built for monitoring: a reliable is_depegged flag and a configurable threshold.
- A second price source confirms a depeg, so one bad price feed does not look like a crisis.
- Supply by chain and its 24h, 7d and 30d change show redemptions or bank-run pressure.
- Watchlist of many stablecoins per run; delta mode returns only state changes.
- No account or API key.

### What makes this different

Price trackers show a chart. This Actor returns a machine-readable depeg verdict with deviation, confirmation from a second source and supply change by chain, ready to trigger alerts.

### Who can use the Stablecoin Depeg Monitor and how?

- **DeFi users and treasuries:** get warned before a stablecoin you hold or lend loses its peg.
- **Risk and compliance teams:** monitor stablecoin exposure with a documented threshold.
- **Alert and bot builders:** trigger Telegram, Discord or Slack alerts on depegs with delta mode.
- **Traders:** spot depeg arbitrage opportunities and supply-driven stress.
- **Researchers:** collect peg deviation and supply history over time.
- **Journalists:** source and cite peg status during a stablecoin event.
- **Protocol teams:** watch collateral stablecoins in a lending market.
- **Fintech developers:** add a stablecoin health widget through the API.

### How it works

![Stablecoin Depeg Monitor: Supply, Price & Peg Alerts workflow: your input, collection, output](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/stablecoin-depeg-monitor--how-it-works.png)

1. **Your input** — choose the stablecoins and a depeg threshold.
2. **The Actor collects it** — the Actor reads price and supply data and cross-checks the price with a second source.
3. **Your output** — you get one row per stablecoin (and per large chain) with the depeg verdict.

### What data can you extract?

The dataset has 19 fields per row:

| Field                               | Type    | Description                                          |
| ----------------------------------- | ------- | ---------------------------------------------------- |
| `stablecoin`                        | string  | Stablecoin symbol.                                   |
| `name`                              | string  | Stablecoin name.                                     |
| `chain`                             | string  | all for the total, or a chain name.                  |
| `circulating_supply`                | number  | Circulating supply in USD.                           |
| `circulating_supply_change_24h_pct` | number  | Supply change over 24 hours in percent.              |
| `circulating_supply_change_7d_pct`  | number  | Supply change over 7 days in percent.                |
| `circulating_supply_change_30d_pct` | number  | Supply change over 30 days in percent.               |
| `price_usd`                         | number  | Market price in USD.                                 |
| `price_usd_second_source`           | number  | Price from the second source, null when unavailable. |
| `deviation_from_peg_pct`            | number  | Price deviation from 1 USD in percent.               |
| `is_depegged`                       | boolean | True when the deviation reaches the threshold.       |
| `depeg_confirmed_by_second_source`  | boolean | Whether the second source reaches the same verdict.  |
| `depeg_threshold_pct`               | number  | Threshold used.                                      |
| `second_source_deviation_pct`       | number  | Deviation according to the second source.            |
| `peg_mechanism`                     | string  | How the coin keeps its peg, for example fiat-backed. |
| `fetch_path`                        | string  | defillama or defillama_and_coingecko.                |
| `source`                            | string  | Data sources.                                        |
| `scraped_at`                        | string  | Collection time (ISO 8601).                          |
| `actor_version`                     | string  | Output schema version.                               |

### How to use Stablecoin Depeg Monitor: Supply, Price & Peg Alerts

![Stablecoin Depeg Monitor: Supply, Price & Peg Alerts input form](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/stablecoin-depeg-monitor--input.png)

1. Open the Actor and go to the **Input** tab.
2. Enter **Stablecoins** (or leave the default eight), set the **Depeg threshold (%)**, and turn on **Only depegged** for an alert feed.
3. Optionally set filters and a **Max results** limit.
4. Click **Start**. A default run finishes in under a minute.
5. Open the **Output** tab, then download the dataset or connect it to your tools.

### Input Parameters

| Parameter            | Type    | Required | Default                   | Description                                                                                          |
| -------------------- | ------- | -------- | ------------------------- | ---------------------------------------------------------------------------------------------------- |
| `stablecoins`        | array   | No       | `[]`                      | Stablecoin symbols to check, one per line. USD-pegged coins only. Leave empty for the eight largest. |
| `depegThresholdPct`  | number  | No       | `0.5`                     | A stablecoin counts as depegged when its price is at least this many percent away from 1 USD.        |
| `topChains`          | integer | No       | `3`                       | Besides the total, return the largest chains by supply. Set 0 for totals only.                       |
| `onlyDepegged`       | boolean | No       | `false`                   | Return rows only for stablecoins beyond the threshold. Ideal for alerts.                             |
| `maxItems`           | integer | No       | `200`                     | Maximum number of rows returned. Set 0 for no limit.                                                 |
| `deltaMode`          | boolean | No       | `false`                   | Return and bill only rows whose depeg state changed since the last run with the same delta key.      |
| `deltaStateKey`      | string  | No       | `"default"`               | Name of the tracked stream.                                                                          |
| `proxyConfiguration` | object  | No       | `{"useApifyProxy":false}` | Optional proxy. The public data services work without one.                                           |

### Output Data

![Stablecoin Depeg Monitor: Supply, Price & Peg Alerts dataset table](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/stablecoin-depeg-monitor--output.png)

`deviation_from_peg_pct` is (price − 1) × 100. `is_depegged` is true when the absolute deviation is at least the threshold. `depeg_confirmed_by_second_source` is true when a second price source reaches the same verdict, false when it disagrees and null when no second price exists. Supply change fields compare the current circulating supply with 1 day, 7 days and 30 days ago. Rows with `chain: all` are the total across chains.

![Stablecoin Depeg Monitor: Supply, Price & Peg Alerts field map of one record](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/stablecoin-depeg-monitor--fields.png)

A real dataset item:

```json
{
    "stablecoin": "USDT",
    "name": "Tether",
    "chain": "all",
    "circulating_supply": 183727681018,
    "circulating_supply_change_24h_pct": 0.14,
    "circulating_supply_change_7d_pct": 0.211,
    "circulating_supply_change_30d_pct": 0.316,
    "price_usd": 0.99978,
    "price_usd_second_source": 0.99983,
    "deviation_from_peg_pct": -0.022,
    "is_depegged": false,
    "depeg_confirmed_by_second_source": true,
    "depeg_threshold_pct": 0.5,
    "second_source_deviation_pct": -0.0169,
    "peg_mechanism": "fiat-backed",
    "fetch_path": "defillama_and_coingecko",
    "source": "defillama_coingecko",
    "scraped_at": "2026-09-25T20:59:10.145Z",
    "actor_version": "1.0.0"
}
```

### How to read and use the results

1. **Filter is_depegged = true** for current depegs.
2. **Check depeg_confirmed_by_second_source**: true means both sources agree.
3. **Read deviation_from_peg_pct**: negative is below the dollar.
4. **Compare supply changes** (24h, 7d, 30d) with the price move.
5. **Look at the chain rows** to see where supply is leaving.
6. **Automate** with a schedule, Only depegged and a webhook.

### Usage Examples

#### Check the big stablecoins

```json
{
    "stablecoins": ["USDT", "USDC", "DAI", "USDE"],
    "topChains": 3
}
```

#### Alert feed: only depegged

```json
{
    "stablecoins": ["USDT", "USDC", "DAI", "USDE", "FDUSD", "PYUSD"],
    "depegThresholdPct": 0.3,
    "onlyDepegged": true
}
```

#### Only when the state changes

```json
{
    "stablecoins": ["USDT", "USDC", "DAI"],
    "topChains": 0,
    "deltaMode": true,
    "deltaStateKey": "peg-alerts"
}
```

### Tips for Best Results

- Schedule every 5 to 15 minutes with Only depegged on and connect a webhook to Slack or Telegram.
- Use 0.3 to 0.5 percent as a threshold for major coins and a wider one for smaller ones.
- Look at supply change alongside price: shrinking supply with a falling price is redemption pressure.
- Treat a depeg that is not confirmed by the second source as a data warning first.
- Default is 5 results for a fast test. Set the max to 0 to return everything available.

### Reliability by mode

| Mode                             | Status | Needs login or key? | Notes                             |
| -------------------------------- | ------ | ------------------- | --------------------------------- |
| Price vs peg for USD stablecoins | ✅     | No                  | Two independent price sources.    |
| Supply totals and by chain       | ✅     | No                  | Aggregated by DefiLlama.          |
| Second price confirmation        | 🟡     | No                  | Public API with a rate limit.     |
| Non-USD pegs (EUR, gold)         | ❌     | -                   | Not supported for peg checks.     |
| Intra-minute depegs              | ❌     | -                   | Snapshot per run; schedule often. |

✅ works as described, 🟡 works with caveats, ❌ not supported.

### Only new records (delta mode)

Turn on **Only changes (delta mode)** and set a **Delta key**. Each run returns, and bills, only rows whose depeg state changed since the previous run of that key, for example a coin that just slipped below the threshold or recovered.

### Known Limitations

- Only USD-pegged stablecoins are checked against a 1 USD peg; euro, gold and other pegs are reported as not supported.
- Prices are aggregated market prices, not order-book prices on one exchange; a thin market can show larger swings.
- Supply is aggregated from on-chain data by the data provider and can lag by minutes to hours.
- The second source is a public price API with limited rate; when it is unavailable the row shows a null second price and confirmation.
- Rows show the state at collection time. Very short depegs between runs can be missed; schedule frequently.
- This is market data, not investment advice.

### Integrations

Run it from the Apify API, on a schedule, or from a webhook. Send results straight to Google Sheets, Make, Zapier, Slack or your own database with Apify's built-in integrations.

### Export Formats

Download the dataset as JSON, CSV, Excel, XML, HTML table or RSS from the **Output** tab or the API.

### Frequently Asked Questions

#### Where does the data come from?

Supply and the main price come from DefiLlama's public stablecoin API, which aggregates on-chain supply. The second price source is CoinGecko's public API.

#### Does it need an API key?

No.

#### What counts as a depeg?

A price at least the threshold away from 1 USD, 0.5 percent by default. You can change it.

#### How do I get an alert when a stablecoin depegs?

Schedule the Actor every few minutes with Only depegged on, and attach a webhook. You are billed only for rows returned.

#### Does it support EURC or gold tokens?

Not for peg checks; the Actor warns that they are not USD-pegged.

#### Am I charged for failed results?

No. You are only charged for rows written to the dataset.

#### Do I need an account or login?

No. The Actor reads public data services and needs no account or API key.

#### Am I charged for failed runs or empty results?

You are only charged for results that are actually written to the dataset.

#### Can I run it on a schedule?

Yes. Create a Task with your input and add a schedule in Apify Console. With monitor mode on, each scheduled run returns only what changed since the previous one.

### Changelog

- **2026-09-26:** First release: peg deviation, depeg flag with second-source confirmation, supply by chain and supply change.

### Enterprise and custom work

Need higher volumes, a custom output schema, dedicated scheduling or a no-breaking-changes commitment for a production pipeline? Open an issue on the Actor page and describe your use case. Bulk terms and custom builds are available.

### Support

Questions or a missing field? Open an issue from the **Issues** tab on this Actor's page and it will be looked at.

### Legal / Responsible Use

This Actor reads public market data from DefiLlama and CoinGecko within their rate limits. You are responsible for how you use it. It is not investment advice and not affiliated with either provider.

# Actor input Schema

## `stablecoins` (type: `array`):

Stablecoin symbols to check, one per line. USD-pegged coins only. Leave empty for the eight largest.

## `depegThresholdPct` (type: `number`):

A stablecoin counts as depegged when its price is at least this many percent away from 1 USD.

## `topChains` (type: `integer`):

Besides the total, return the largest chains by supply. Set 0 for totals only.

## `onlyDepegged` (type: `boolean`):

Return rows only for stablecoins beyond the threshold. Ideal for alerts.

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

Maximum number of rows returned. Set 0 for no limit.

## `deltaMode` (type: `boolean`):

Return and bill only rows whose depeg state changed since the last run with the same delta key.

## `deltaStateKey` (type: `string`):

Name of the tracked stream.

## `proxyConfiguration` (type: `object`):

Optional proxy. The public data services work without one.

## Actor input object example

```json
{
  "stablecoins": [
    "USDT",
    "USDC",
    "DAI",
    "USDE",
    "FDUSD",
    "PYUSD"
  ],
  "depegThresholdPct": 0.5,
  "topChains": 3,
  "onlyDepegged": false,
  "maxItems": 200,
  "deltaMode": false,
  "deltaStateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "stablecoins": [
        "USDT",
        "USDC",
        "DAI",
        "USDE",
        "FDUSD",
        "PYUSD"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrdoe/stablecoin-depeg-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 = {
    "stablecoins": [
        "USDT",
        "USDC",
        "DAI",
        "USDE",
        "FDUSD",
        "PYUSD",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("mrdoe/stablecoin-depeg-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 '{
  "stablecoins": [
    "USDT",
    "USDC",
    "DAI",
    "USDE",
    "FDUSD",
    "PYUSD"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call mrdoe/stablecoin-depeg-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/stablecoin-depeg-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/qlguGsjQ2I64lXzvb/builds/RHDnIYcliLkDetsHt/openapi.json
