# Kraken Crypto Price & Order Book Scraper (`shaggydev/kraken-crypto-market-data-connector`) Actor

Kraken crypto market data scraper using official public REST API. Extract spot prices, bid/ask, spread, 24h volume, VWAP, highs/lows, trade count, resolved pairs, and optional order book snapshots for BTC, ETH, SOL, XBT/USD, and bulk symbols. No API key.

- **URL**: https://apify.com/shaggydev/kraken-crypto-market-data-connector.md
- **Developed by:** [Michael](https://apify.com/shaggydev) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN 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 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

### What does Kraken Crypto Price & Order Book Scraper do?

Kraken Crypto Price & Order Book Scraper collects public spot-market cryptocurrency data from Kraken's official public REST API. It fetches live ticker metadata, 24h market statistics, bid/ask spread, resolved Kraken trading pairs, and optional order book snapshots for crypto symbols and pairs.

Use it for crypto price monitoring, BTC/ETH/SOL dashboards, exchange market-data checks, spread analysis, arbitrage research, portfolio reporting, trading bot inputs, and automated market alerts. The actor writes clean structured rows to an Apify dataset, so you can export results as JSON, CSV, Excel, HTML, RSS, or consume them through the Apify API.

This actor does not use private Kraken account APIs, API keys, browser automation, exchange website scraping, or trading endpoints. It only reads public market data.

### Why use this Kraken crypto market data scraper?

- Scrape Kraken crypto prices from official public API endpoints.
- Fetch spot ticker data for BTC, ETH, SOL, XBT/USD, ETH/USD, and other Kraken-supported pairs.
- Resolve flexible user inputs such as `BTC`, `XBT`, `BTC/USD`, `BTC-USD`, and `XBTUSD`.
- Extract best bid, best ask, bid/ask spread, 24h volume, VWAP, high, low, open, and trade count.
- Include top bid/ask order book levels when `includeOrderBook` is enabled.
- Run bulk symbol checks with conservative rate limiting.
- Schedule recurring crypto market data pulls on Apify.
- Avoid API key setup because Kraken public market data does not require private credentials.

### What data can it extract?

| Field | Description |
| --- | --- |
| `inputSymbol` | Original symbol or pair entered by the user |
| `exchange` | `kraken` |
| `pair` | Resolved Kraken market pair, such as `XBT/USD` |
| `krakenPairId` | Kraken internal pair ID |
| `base` | Base asset |
| `quote` | Quote asset |
| `price` | Last traded price |
| `bid` | Best bid |
| `ask` | Best ask |
| `spread` | Bid/ask spread |
| `priceChange24h` | Estimated 24h percent change from Kraken ticker data |
| `volume24hBase` | 24h base-asset volume |
| `volume24hQuote` | Estimated 24h quote-volume value |
| `vwap24h` | 24h volume-weighted average price |
| `high24h` | 24h high |
| `low24h` | 24h low |
| `open24h` | 24h open |
| `tradeCount24h` | 24h trade count |
| `orderBook` | Optional bids and asks snapshot |
| `timestamp` | Scraped timestamp |
| `dataSource` | Kraken public REST API |
| `scrapeStatus` | `ok`, `partial`, or `failed` |
| `metadataConfidence` | Confidence flag based on available fields |

### Input options

#### Symbols or pairs

Enter Kraken spot symbols or pairs in bulk:

```json
{
  "symbols": [
    "BTC",
    "ETH",
    "SOL",
    "BTC/USD",
    "XBTUSD"
  ],
  "defaultQuoteCurrency": "USD",
  "includeOrderBook": true,
  "orderBookDepth": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 1,
  "requestDelayMs": 1000
}
````

Single symbols use `defaultQuoteCurrency`, so `BTC` resolves to the available BTC/USD style market where possible. Kraken commonly uses `XBT` for Bitcoin internally; this actor accepts both `BTC` and `XBT` style inputs.

#### Order book snapshots

Set `includeOrderBook` to `true` to return a top-of-book snapshot from Kraken's public depth endpoint. Use `orderBookDepth` to control how many bid and ask levels are returned per pair.

For high-frequency price checks, disable order books to reduce requests and output size:

```json
{
  "symbols": ["BTC", "ETH", "SOL"],
  "includeOrderBook": false,
  "requestDelayMs": 1000
}
```

### Example output

```json
{
  "inputSymbol": "BTC",
  "exchange": "kraken",
  "pair": "XBT/USD",
  "krakenPairId": "XXBTZUSD",
  "base": "XBT",
  "quote": "USD",
  "price": 69000.12,
  "bid": 68999.5,
  "ask": 69000.8,
  "spread": 1.3,
  "priceChange24h": 1.2475,
  "volume24hBase": 1245.85,
  "volume24hQuote": 85898222.14,
  "vwap24h": 68950.44,
  "high24h": 70100.0,
  "low24h": 68125.2,
  "open24h": 68150.0,
  "tradeCount24h": 34210,
  "orderBook": {
    "bids": [[68999.5, 0.25, 1717430000]],
    "asks": [[69000.8, 0.18, 1717430000]]
  },
  "timestamp": "2026-06-03T12:15:00.000Z",
  "dataSource": "Kraken public REST API",
  "scrapeStatus": "ok",
  "metadataConfidence": "high"
}
```

### How to scrape Kraken crypto prices on Apify

1. Add one or more crypto symbols or Kraken spot pairs.
2. Choose the default quote currency for single-symbol inputs.
3. Decide whether you need order book snapshots.
4. Keep `requestDelayMs` conservative for large runs.
5. Run the actor and export the dataset or access it through the Apify API.
6. Schedule recurring runs for price monitoring, alerts, dashboards, or reporting.

### Supported crypto symbols and pairs

The actor supports Kraken spot markets available from Kraken's public `AssetPairs`, `Ticker`, and `Depth` endpoints. Common examples include:

- `BTC`, `XBT`, `BTC/USD`, `XBTUSD`
- `ETH`, `ETH/USD`, `ETHUSDT`
- `SOL`, `SOL/USD`
- Other Kraken-supported spot assets and pairs

If a symbol cannot be resolved to a Kraken spot pair, the actor writes a failed row with an error message instead of silently dropping the input.

### Reliability notes

Kraken public endpoints are rate limited. The default configuration uses one worker and a one-second delay to stay conservative. Increase `maxConcurrency` only if you understand Kraken's public API limits and your expected run volume.

Apify Proxy is usually not needed for Kraken public API calls. The default input leaves proxy usage disabled. Enable proxy routing only if your environment requires it.

### Pricing notes

This actor is designed for pay-per-event pricing. The primary event is `crypto-result`, charged once for each usable Kraken symbol or pair result written to the dataset. Failed rows are reported for visibility but are not intended to be charged as successful crypto results.

Cost mainly depends on the number of symbols, whether order book snapshots are enabled, request delay, and run frequency. For the lowest cost, use fewer symbols, disable order books when you only need ticker data, and schedule runs at the minimum useful frequency.

### Compliance and limitations

This actor returns public Kraken spot market metadata for informational use only. It does not place trades, access accounts, manage balances, execute orders, provide investment advice, or guarantee market prices.

Crypto markets are volatile. Exchange data can be delayed, unavailable, incomplete, or temporarily inconsistent. Always verify critical trading decisions with your own systems and official exchange data.

### Common use cases

- Kraken BTC price monitoring
- Ethereum and Solana spot market dashboards
- Crypto spread and bid/ask analysis
- Order book snapshot collection
- Portfolio reporting inputs
- Trading bot market-data feeds
- Arbitrage research and exchange monitoring
- Scheduled crypto market alerts with Apify webhooks

### FAQ

#### Does this actor require a Kraken API key?

No. It uses Kraken public REST API endpoints only.

#### Does it support Bitcoin as BTC and XBT?

Yes. Kraken uses `XBT` internally, but the actor accepts common `BTC` inputs and resolves them to Kraken pairs where available.

#### Does it place trades?

No. This is market-data collection only. It never calls private account or order endpoints.

#### Can I use this for bulk crypto symbols?

Yes. Add multiple symbols or pairs to `symbols`. Keep concurrency and request delays conservative for larger runs.

# Actor input Schema

## `symbols` (type: `array`):

Kraken spot symbols or pairs, one per line. Single assets use the selected quote currency, e.g. BTC with USD becomes BTC/USD when available.

## `defaultQuoteCurrency` (type: `string`):

Quote currency used when a symbol is entered without a quote, e.g. BTC -> BTC/USD.

## `includeOrderBook` (type: `boolean`):

Include a top-of-book snapshot from Kraken's public Depth endpoint.

## `orderBookDepth` (type: `integer`):

Number of bid/ask levels to return per pair.

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

Optional Apify Proxy routing. Usually not needed for Kraken public API access.

## `maxConcurrency` (type: `integer`):

Number of pairs processed in parallel. Keep low to respect Kraken public API limits.

## `requestDelayMs` (type: `integer`):

Delay before each pair request. Kraken recommends public calls at 1 request per second or less to remain within limits.

## Actor input object example

```json
{
  "symbols": [
    "BTC",
    "ETH",
    "SOL",
    "BTC/USD"
  ],
  "defaultQuoteCurrency": "USD",
  "includeOrderBook": true,
  "orderBookDepth": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 1,
  "requestDelayMs": 1000
}
```

# Actor output Schema

## `results` (type: `string`):

URL to the default dataset items.

# 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 = {
    "symbols": [
        "BTC",
        "ETH",
        "SOL",
        "BTC/USD"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shaggydev/kraken-crypto-market-data-connector").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 = {
    "symbols": [
        "BTC",
        "ETH",
        "SOL",
        "BTC/USD",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("shaggydev/kraken-crypto-market-data-connector").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 '{
  "symbols": [
    "BTC",
    "ETH",
    "SOL",
    "BTC/USD"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call shaggydev/kraken-crypto-market-data-connector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shaggydev/kraken-crypto-market-data-connector",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kraken Crypto Price & Order Book Scraper",
        "description": "Kraken crypto market data scraper using official public REST API. Extract spot prices, bid/ask, spread, 24h volume, VWAP, highs/lows, trade count, resolved pairs, and optional order book snapshots for BTC, ETH, SOL, XBT/USD, and bulk symbols. No API key.",
        "version": "1.0",
        "x-build-id": "jTtr14CF1gQggxAhN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shaggydev~kraken-crypto-market-data-connector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shaggydev-kraken-crypto-market-data-connector",
                "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/shaggydev~kraken-crypto-market-data-connector/runs": {
            "post": {
                "operationId": "runs-sync-shaggydev-kraken-crypto-market-data-connector",
                "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/shaggydev~kraken-crypto-market-data-connector/run-sync": {
            "post": {
                "operationId": "run-sync-shaggydev-kraken-crypto-market-data-connector",
                "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",
                "required": [
                    "symbols"
                ],
                "properties": {
                    "symbols": {
                        "title": "Symbols or Pairs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Kraken spot symbols or pairs, one per line. Single assets use the selected quote currency, e.g. BTC with USD becomes BTC/USD when available.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "defaultQuoteCurrency": {
                        "title": "Default Quote Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "USDT",
                            "USDC",
                            "BTC",
                            "ETH"
                        ],
                        "type": "string",
                        "description": "Quote currency used when a symbol is entered without a quote, e.g. BTC -> BTC/USD.",
                        "default": "USD"
                    },
                    "includeOrderBook": {
                        "title": "Include Order Book",
                        "type": "boolean",
                        "description": "Include a top-of-book snapshot from Kraken's public Depth endpoint.",
                        "default": true
                    },
                    "orderBookDepth": {
                        "title": "Order Book Depth",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of bid/ask levels to return per pair.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy routing. Usually not needed for Kraken public API access.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pairs processed in parallel. Keep low to respect Kraken public API limits.",
                        "default": 1
                    },
                    "requestDelayMs": {
                        "title": "Delay Between Requests",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Delay before each pair request. Kraken recommends public calls at 1 request per second or less to remain within limits.",
                        "default": 1000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
