# 🪙 Stablecoin Supply & Peg Monitor — Circulating & Depeg (`nexgendata/stablecoin-supply-peg-monitor`) Actor

Monitor stablecoin circulating supply, price/peg deviation, and supply changes (1d/7d/30d) by chain. For crypto desks, risk teams, and treasuries tracking de-peg and supply-contraction risk.

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

## Pricing

from $25.00 / 1,000 page scrapeds

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

## 🪙 Stablecoin Supply & Peg Monitor — Circulating & Depeg

**Live stablecoin circulating supply, peg deviation, and 7-day supply momentum by chain — the risk signal Nansen and Messari charge a subscription for, delivered as pay-per-record JSON.**

Stablecoins are the plumbing of crypto, and when the plumbing leaks — a depeg, a sudden supply contraction, a chain-level migration of liquidity — it moves fast and it moves first. This actor monitors the stablecoin universe and returns, for each coin, its circulating supply, its current price relative to peg, its recent supply change, and the number of chains it spans. For a trading desk, a treasury holding stablecoin reserves, or a risk team watching counterparty exposure, those are the four numbers that tell you whether a stablecoin is healthy, draining, or breaking.

The value is in the read you can build from it: a price that has drifted off 1.00, a circulating supply shrinking 7 days running, a coin concentrated on a single chain — each is an early warning. Pull the universe on a schedule and you have a continuously updated depeg-and-contraction dashboard without paying for a full on-chain analytics seat.

### Why use this

Stablecoin health data exists on platforms like Nansen and Messari, but it comes wrapped in a subscription built for analysts clicking through dashboards, not for a pipeline that needs the numbers in JSON. You cannot easily ask those tools "give me every peggedUSD coin over $100M, sorted by 7-day supply change, as a flat file my risk model ingests every hour." This actor is exactly that: a filterable, queryable feed of the metrics that matter for stablecoin risk.

It runs pay-per-result — you pay for the coins you pull, with no seat licence and no monthly commitment. The output is flat JSON ready to drop into a warehouse, a spreadsheet, or an LLM. And it is purpose-built for the risk question rather than the explorer question: price/peg deviation and supply momentum are front-and-center fields, not metrics you have to derive by hand.

- **Depeg detection out of the box.** The `price` field against the implied peg is the depeg signal; filter or sort on it to surface coins drifting off their target.
- **Supply momentum, not just a snapshot.** `pctChange7d` captures whether a coin is being minted or redeemed — supply contraction is one of the cleanest leading indicators of stress.
- **Chain spread as a concentration read.** `chainCount` tells you whether a coin's liquidity is diversified or concentrated on a single chain, which matters for both risk and redemption mechanics.

### What you get

Each record returned by the actor is one stablecoin, in flat JSON:

- `name` — the stablecoin's full name
- `symbol` — its ticker (e.g. USDT, USDC, DAI)
- `pegType` — the asset it is pegged to (peggedUSD, peggedEUR, etc.)
- `price` — current price; deviation from the implied peg is your depeg signal
- `circulating` — circulating supply in USD
- `pctChange7d` — percentage change in supply over the trailing 7 days
- `chainCount` — number of chains the stablecoin is deployed across

The schema is stable and additive — safe to load straight into a time-series store and refresh on a tight schedule.

### Use cases

- **Depeg monitoring.** Schedule the actor hourly, alert when any tracked coin's `price` drifts beyond a tolerance band from its peg, and route the alert to your desk or risk channel before the move is obvious on a chart.
- **Supply-contraction early warning.** Watch `pctChange7d` for sustained negative readings — a stablecoin steadily redeeming is often the first visible sign of confidence draining, ahead of any price break.
- **Treasury reserve risk.** If your treasury holds stablecoin reserves, track the health of exactly the coins you hold and set thresholds on peg deviation and supply change to trigger a rebalance review.
- **Counterparty exposure screening.** Before accepting a stablecoin as collateral or settlement, check its circulating supply, peg stability, and chain spread to gauge concentration and redemption risk.
- **Market-share and flows research.** Sort the universe by `circulating` to track which stablecoins are gaining or losing share, and use `chainCount` to see where liquidity is migrating across chains.
- **Stablecoin-basket construction.** Filter by `pegType` and `minCirculating` to build a screened basket of liquid, on-peg coins for a stablecoin yield or settlement strategy.
- **Macro / de-dollarization research.** Compare peggedUSD against peggedEUR and other peg types to track non-USD stablecoin growth as a slow-moving macro signal.

### Sample output

```json
{
  "name": "Tether",
  "symbol": "USDT",
  "pegType": "peggedUSD",
  "price": 0.9998,
  "circulating": 112430000000,
  "pctChange7d": 1.42,
  "chainCount": 14
}
````

A run sorted by `pctChange7d` ascending surfaces the coins whose supply is contracting fastest — the watchlist a risk desk wants at the top of the screen.

### Input parameters

| Parameter | Label | Description |
|---|---|---|
| `nameContains` | Name contains | Filter by stablecoin name (e.g. `USDT`). |
| `pegType` | Peg type | Filter by peg type (e.g. `peggedUSD`, `peggedEUR`). |
| `minCirculating` | Min circulating (USD) | Minimum circulating supply in USD. |
| `sortBy` | Sort by | Field to sort the results by. |
| `maxResults` | Max results | Maximum number of stablecoins to return. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/stablecoin-supply-peg-monitor").call(run_input={
    "pegType": "peggedUSD",
    "minCirculating": 100000000,
    "sortBy": "pctChange7d",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["symbol"], item["price"], item["pctChange7d"], item["circulating"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~stablecoin-supply-peg-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "pegType": "peggedUSD",
    "minCirculating": 100000000,
    "maxResults": 50
  }'
```

Schedule it hourly via Apify's scheduler and fire a webhook to Slack, Make, or n8n when a coin breaches your peg-deviation or supply-change threshold.

### Pricing

This actor runs on Apify's **pay-per-event** model — **$0.10 per result record**, plus a negligible one-time actor-start charge per run. No subscription, no seat licence, no minimum.

Worked examples:

- Top 50 USD stablecoins, hourly → 50 records × $0.10 = **~$5.00 per run**
- A focused watchlist of 10 coins, every 15 minutes → 10 × $0.10 = **~$1.00 per run**
- The full stablecoin universe (~100 coins), once daily → **~$10.00 per run**

You pay only for records pushed to the dataset. Apify's free monthly tier covers most exploratory runs. Browse the full catalog at https://apify.com/nexgendata?fpr=2ayu9b

### How this compares to Nansen / Messari

| Source | Price | What you get |
|---|---|---|
| Nansen | ~$thousands / yr per seat | On-chain analytics dashboards, wallet labels, flows — seat-locked, dashboard-first |
| Messari | ~$thousands / yr per seat | Research, metrics, and screeners across crypto — subscription, UI-oriented |
| **NexGenData Stablecoin Supply & Peg Monitor** | **PPE $0.10 / record** | **Circulating supply, peg deviation, 7-day supply change, and chain spread per coin, as flat JSON** |

Nansen and Messari are broad analytics platforms — if you need wallet-level flows, labelled addresses, and a full research workspace, they earn their subscription. But if the specific job is *monitoring stablecoin supply and peg health as a data feed*, this actor delivers those exact metrics in a form your own systems can consume, priced per record instead of per seat.

### FAQ

**Q: How is depeg measured?**
A: The `price` field reports the stablecoin's current price; compare it to its implied peg (1.00 for peggedUSD) and your chosen tolerance band to detect a depeg. The actor gives you the raw number so you set the threshold that fits your risk policy.

**Q: What does `pctChange7d` represent?**
A: The percentage change in the coin's circulating supply over the trailing 7 days — positive means net minting, negative means net redemption. Sustained negative readings are a common early stress signal.

**Q: Can I filter to only large coins?**
A: Yes — set `minCirculating` to your floor (e.g. 100000000 for $100M+) to exclude thinly-circulating coins from the run.

**Q: How fresh is the data?**
A: Each run reads live, so results reflect current supply and price at run time. For depeg monitoring, schedule it hourly or tighter.

**Q: Does it cover non-USD stablecoins?**
A: Yes — filter by `pegType` (peggedUSD, peggedEUR, and others) to focus on or compare across peg types.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added over time as new JSON keys (defaulting to `null` for older records), but existing fields are never renamed or removed without a major-version bump and advance notice. Date and numeric semantics are never silently changed. Build your time-series ETL on the seven documented fields with confidence.

### Compliance & legal

- The actor reads public, aggregated stablecoin market data — no authentication, no private endpoints, no credentials stored.
- Output is informational market data, not investment advice; verify against primary sources before acting on a depeg or contraction signal.
- You are responsible for ensuring your downstream use complies with your jurisdiction's financial-data and market-conduct rules.

### Related NexGenData actors

Part of NexGenData's crypto & DeFi intelligence lane — pair this actor with:

- [DeFi TVL Protocol Tracker](https://apify.com/nexgendata/defi-tvl-protocol-tracker?fpr=2ayu9b) — total value locked by protocol and chain
- [Crypto Perp Funding Rates Tracker](https://apify.com/nexgendata/crypto-perp-funding-rates-tracker?fpr=2ayu9b) — perpetual-swap funding across venues
- [Crypto Top 100 Screener](https://apify.com/nexgendata/crypto-top100-screener?fpr=2ayu9b) — price, market cap, and momentum across the majors
- [Kalshi Prediction Markets Tracker](https://apify.com/nexgendata/kalshi-prediction-markets-tracker?fpr=2ayu9b) — event-contract odds and volume
- [Polymarket Prediction Markets Tracker](https://apify.com/nexgendata/polymarket-prediction-markets-tracker?fpr=2ayu9b) — on-chain prediction-market pricing
- [Crypto/DeFi MCP](https://apify.com/nexgendata/crypto-defi-mcp?fpr=2ayu9b) — model-context-protocol bridge for crypto data from any MCP client

Explore the full catalog of 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

# Actor input Schema

## `nameContains` (type: `string`):

Filter by stablecoin name (e.g. 'USDT').

## `pegType` (type: `string`):

Filter by peg type (e.g. peggedUSD, peggedEUR).

## `minCirculating` (type: `integer`):

Minimum circulating supply in USD.

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

Field to sort by.

## `maxResults` (type: `integer`):

Maximum stablecoins to return.

## Actor input object example

```json
{
  "sortBy": "circulating",
  "maxResults": 500
}
```

# 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("nexgendata/stablecoin-supply-peg-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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🪙 Stablecoin Supply & Peg Monitor — Circulating & Depeg",
        "description": "Monitor stablecoin circulating supply, price/peg deviation, and supply changes (1d/7d/30d) by chain. For crypto desks, risk teams, and treasuries tracking de-peg and supply-contraction risk.",
        "version": "0.0",
        "x-build-id": "H3dQMdYSBDhUMjzfF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~stablecoin-supply-peg-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-stablecoin-supply-peg-monitor",
                "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~stablecoin-supply-peg-monitor/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-stablecoin-supply-peg-monitor",
                "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~stablecoin-supply-peg-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-stablecoin-supply-peg-monitor",
                "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": {
                    "nameContains": {
                        "title": "Name contains",
                        "type": "string",
                        "description": "Filter by stablecoin name (e.g. 'USDT')."
                    },
                    "pegType": {
                        "title": "Peg type",
                        "type": "string",
                        "description": "Filter by peg type (e.g. peggedUSD, peggedEUR)."
                    },
                    "minCirculating": {
                        "title": "Min circulating (USD)",
                        "type": "integer",
                        "description": "Minimum circulating supply in USD."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "circulating",
                            "pctChange1d",
                            "pctChange7d",
                            "pctChange30d",
                            "price"
                        ],
                        "type": "string",
                        "description": "Field to sort by.",
                        "default": "circulating"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum stablecoins to return.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```