# Stablecoin Market Intelligence (`gochujang/stablecoin-market-intel`) Actor

Track the full stablecoin ecosystem: supply, cross-chain distribution, peg health, market share, and inflow/outflow trends. Covers 400+ stablecoins via DefiLlama. No API key required. Monitor USDT/USDC dominance, spot emerging stablecoins, and detect depeg risks.

- **URL**: https://apify.com/gochujang/stablecoin-market-intel.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Developer tools, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Stablecoin Market Intelligence

> Track the full stablecoin ecosystem: **supply, cross-chain distribution, peg health, market share shifts, and 24h/7d/30d flow trends** across 400+ stablecoins. No API key required. **$0.001/stablecoin** (top 20 = $0.02/run).

---

### What It Does

Stablecoin supply and cross-chain flows are one of the best leading indicators of crypto market health. This actor aggregates the complete stablecoin landscape via DefiLlama's free API, returning structured data on:

- **Market share dominance** — USDT vs USDC vs DAI vs emerging stablecoins
- **Supply changes** — Where capital is flowing in and out
- **Cross-chain distribution** — Which networks attract the most stablecoin liquidity
- **Peg health monitoring** — Real-time peg deviation signals
- **New entrant tracking** — Spot fast-growing stablecoins (e.g. USDE, USD1, USDS)

### Example Output

```json
{
  "symbol": "USDT",
  "name": "Tether",
  "peg_type": "peggedUSD",
  "peg_mechanism": "fiat-backed",
  "circulating_usd": 183000000000,
  "market_share_pct": 67.2,
  "price": 0.9991,
  "peg_deviation_pct": 0.09,
  "peg_status": "stable",
  "change_24h_pct": 0.12,
  "change_7d_pct": 0.54,
  "change_30d_pct": 2.1,
  "chains_count": 80,
  "top_chains": [
    {"chain": "Tron", "supply_usd": 72000000000},
    {"chain": "Ethereum", "supply_usd": 62000000000},
    {"chain": "BSC", "supply_usd": 8000000000}
  ]
}
````

### SUMMARY Key-Value Store

Every run also stores a `SUMMARY` record with:

- Total stablecoin market supply
- Top 3 by supply with market share
- Active depeg alerts
- Largest 24h inflows and outflows

### Key Features

- **400+ stablecoins** via DefiLlama's free API
- **Cross-chain supply** — see how supply distributes across Ethereum, Tron, Solana, BSC, Arbitrum, etc.
- **Mechanism filter** — filter to fiat-backed, crypto-backed, or algorithmic stablecoins
- **Depeg alert mode** — only return stablecoins that have deviated >0.5% from peg
- **CoinGecko price supplement** — optionally enhance DefiLlama data with real-time prices

### Input Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `limit` | integer | `20` | Max stablecoins to return (5–200) |
| `minSupplyUsd` | number | `10,000,000` | Filter out tiny stablecoins below this threshold |
| `sortBy` | string | `"circulating"` | Sort by: `circulating`, `market_share`, `change_24h`, `depeg`, `chains` |
| `filterMechanism` | string | `""` (all) | Filter to: `fiat-backed`, `crypto-backed`, `algorithmic`, `over-collateralized` |
| `depegAlertOnly` | boolean | `false` | Only return stablecoins with >0.5% peg deviation |
| `includeCoinGeckoPrices` | boolean | `true` | Supplement with CoinGecko real-time prices |

### Pricing

- **$0.001 per stablecoin tracked**
- Top 20 stablecoins = **$0.02** per run
- Top 100 stablecoins = **$0.10** per run
- Ideal for hourly or daily scheduling

### Use Cases

**Daily stablecoin health snapshot (top 30):**

```json
{
  "limit": 30,
  "sortBy": "circulating",
  "includeCoinGeckoPrices": true
}
```

**Monitor for depeg risks:**

```json
{
  "limit": 100,
  "depegAlertOnly": true,
  "sortBy": "depeg"
}
```

**Track fastest-growing stablecoins (last 24h):**

```json
{
  "limit": 50,
  "minSupplyUsd": 1000000,
  "sortBy": "change_24h"
}
```

**Fiat-backed only for compliance monitoring:**

```json
{
  "filterMechanism": "fiat-backed",
  "limit": 20
}
```

### Data Source

- [DefiLlama Stablecoin API](https://stablecoins.llama.fi) — free, 400+ stablecoins, cross-chain supply data, peg prices
- [CoinGecko](https://api.coingecko.com) — supplementary real-time price data

# Actor input Schema

## `limit` (type: `integer`):

Maximum number of stablecoins to return (5-200).

## `minSupplyUsd` (type: `number`):

Only include stablecoins with circulating supply above this threshold.

## `sortBy` (type: `string`):

Ranking criterion.

## `filterMechanism` (type: `string`):

Filter stablecoins by backing mechanism. Leave empty for all.

## `depegAlertOnly` (type: `boolean`):

Only return stablecoins that have deviated more than 0.5% from their peg.

## `includeCoinGeckoPrices` (type: `boolean`):

Fetch more accurate real-time prices from CoinGecko for the top 50 stablecoins.

## Actor input object example

```json
{
  "limit": 20,
  "minSupplyUsd": 10000000,
  "sortBy": "circulating",
  "filterMechanism": "",
  "depegAlertOnly": false,
  "includeCoinGeckoPrices": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/stablecoin-market-intel").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/stablecoin-market-intel").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 gochujang/stablecoin-market-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=gochujang/stablecoin-market-intel",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stablecoin Market Intelligence",
        "description": "Track the full stablecoin ecosystem: supply, cross-chain distribution, peg health, market share, and inflow/outflow trends. Covers 400+ stablecoins via DefiLlama. No API key required. Monitor USDT/USDC dominance, spot emerging stablecoins, and detect depeg risks.",
        "version": "0.1",
        "x-build-id": "OWru4fhHJhAWXaHVo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gochujang~stablecoin-market-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gochujang-stablecoin-market-intel",
                "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/gochujang~stablecoin-market-intel/runs": {
            "post": {
                "operationId": "runs-sync-gochujang-stablecoin-market-intel",
                "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/gochujang~stablecoin-market-intel/run-sync": {
            "post": {
                "operationId": "run-sync-gochujang-stablecoin-market-intel",
                "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": {
                    "limit": {
                        "title": "Max Stablecoins",
                        "minimum": 5,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of stablecoins to return (5-200).",
                        "default": 20
                    },
                    "minSupplyUsd": {
                        "title": "Min Supply (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include stablecoins with circulating supply above this threshold.",
                        "default": 10000000
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "circulating",
                            "market_share",
                            "change_24h",
                            "depeg",
                            "chains"
                        ],
                        "type": "string",
                        "description": "Ranking criterion.",
                        "default": "circulating"
                    },
                    "filterMechanism": {
                        "title": "Filter by Peg Mechanism",
                        "enum": [
                            "",
                            "fiat-backed",
                            "crypto-backed",
                            "algorithmic",
                            "over-collateralized"
                        ],
                        "type": "string",
                        "description": "Filter stablecoins by backing mechanism. Leave empty for all.",
                        "default": ""
                    },
                    "depegAlertOnly": {
                        "title": "Depeg Alerts Only",
                        "type": "boolean",
                        "description": "Only return stablecoins that have deviated more than 0.5% from their peg.",
                        "default": false
                    },
                    "includeCoinGeckoPrices": {
                        "title": "Supplement with CoinGecko Prices",
                        "type": "boolean",
                        "description": "Fetch more accurate real-time prices from CoinGecko for the top 50 stablecoins.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
