# Whale Wallet Tracker (`zinin/whale-wallet-tracker`) Actor

Track large native ETH and ERC-20 token movements for any wallet(s) via Etherscan's multichain API (bring your own key). Get current balance, flagged transfers above your ETH threshold, and recent token transfer activity — one row per wallet. No RPC node, no wallet-connect, no browser.

- **URL**: https://apify.com/zinin/whale-wallet-tracker.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result founds

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Whale Wallet Tracker — Large Native & Token Movements

Watch any wallet for large on-chain movements — without running a node or paying for a dashboard seat. A big native-token transfer often front-runs a market move, and traders, fund managers and crypto-Twitter accounts want to know when one happens; this Actor gives back the current balance, any recent native transactions above a size threshold you set, and recent ERC-20 token transfers, one row per wallet, straight from Etherscan-compatible explorer APIs — no RPC node, no wallet-connect, no browser, and no financial advice attached.

### What you get

- **Current balance, large native movements, and recent token transfers** — one row per wallet, no dashboard subscription.
- **Six EVM chains, keyless**: Ethereum, Optimism, Gnosis, Polygon, Base, Arbitrum — no signup, no API key.
- **The right native currency, not just "ETH".** Balance and movement sizes come back labeled with the chain's real gas token via `nativeSymbol` (`ETH`, `POL`, `xDAI`, `BNB`, …) — a Polygon or BSC wallet is never reported in the wrong unit.
- **Visible source coverage.** If the balance check succeeds but the transaction history call fails (or vice versa), `sourceCoverage` and `sourceErrors` say exactly which one — so "zero large movements" and "couldn't check movements" never collapse into the same row.
- **Bring your own Etherscan key** for chains outside the keyless six (e.g. BSC, `chainId: 56`) or for a higher rate limit than the shared keyless endpoint — billed against your own free quota, never marked up.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON/CSV/Excel, or push straight into your own pipeline.

### How to run it

1. Click **Try for free** — no card, no signup needed on the keyless chains.
2. Paste wallet addresses into **Wallets**, one per line, and set **Minimum native value** to the size that counts as "large" for you.
3. Press **Start** and read the results from the dataset — UI, API or webhook.

### Pricing

Pay-per-event: **$0.005 per run start + $0.005 per result**. You only pay for what you pull. 100 wallets cost about **$0.51**; 1,000 wallets about **$5.01**. No markup on explorer usage — keyless runs cost nothing beyond the Actor's own charge above, and a key (if you add one) bills to your own Etherscan quota, not ours.

A wallet that could not be checked at all is still returned with `found: false` and the reason, and it is **not** charged for.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `wallets` | array of strings | Wallet addresses to track (`0x...`). Up to 100. One row per wallet. |
| `chainId` | integer | EVM chain ID. Keyless out of the box: `1` Ethereum, `10` Optimism, `100` Gnosis, `137` Polygon, `8453` Base, `42161` Arbitrum. Any other chain (e.g. `56` BSC) needs `etherscanApiKey`. Default `1`. |
| `etherscanApiKey` | string (secret), optional | Your own Etherscan API key. Not required for the six keyless chains above — add it for other chains or higher throughput. Never logged, never stored, never returned in output. |
| `minValueEth` | number | Flag native transfers moving at least this much of the chain's native coin as a "large movement". Default `1`. |
| `maxConcurrency` | integer | Parallelism (1–10, default 3). Keep low on the shared keyless endpoint (or a free-tier key) to avoid rate-limit errors. |

```json
{
  "wallets": ["0x28C6c06298d514Db089934071355E5743bf21d60"],
  "minValueEth": 1
}
```

### Output

One dataset row per wallet. This is a real row from a real run, trimmed only where a list repeats:

```json
{
  "wallet": "0x28C6c06298d514Db089934071355E5743bf21d60",
  "chainId": 1,
  "found": true,
  "ethBalance": 215109.977692,
  "nativeBalance": 215109.977692,
  "nativeSymbol": "ETH",
  "largeMovements": [
    { "hash": "0x93b01fdafe0f9d7a35fba48e832c584a1862e478db58434171f52b9c02b64de8", "ts": "2026-07-26T15:05:35.000Z", "direction": "out", "valueEth": 365, "counterparty": "0x6455327f820edd69c4cd665b995e0fec679d7f9e" },
    { "hash": "0xf9c69ad67a5c3c41c3f8984e403cf367511ceaef101ac243af625cb347099924", "ts": "2026-07-26T15:04:35.000Z", "direction": "out", "valueEth": 1508, "counterparty": "0xf8191d98ae98d2f7abdfb63a9b0b812b93c873aa" },
    "…"
  ],
  "tokenTransfers": [
    { "ts": "2026-07-26T15:12:11.000Z", "tokenSymbol": "CFG", "amount": 10374.7676, "direction": "out" },
    { "ts": "2026-07-26T15:12:11.000Z", "tokenSymbol": "USDT", "amount": 266.26, "direction": "out" },
    "…"
  ],
  "movementCount": 3,
  "sourceCoverage": {
    "balance": "ok",
    "nativeTx": "ok",
    "tokenTx": "ok"
  },
  "sourceErrors": {
    "balance": null,
    "nativeTx": null,
    "tokenTx": null
  },
  "summary": "0x28C6c06298d514Db089934071355E5743bf21d60 — 215109.977692 ETH, 3 large native movement(s) ≥ 1 ETH, 20 recent token transfer(s).",
  "checkedAt": "2026-07-26T15:12:23.556Z"
}
```

| Field | Description |
|-------|-------------|
| `wallet` | The address you passed (checksummed as returned) |
| `found` | Whether the wallet could be queried at all |
| `nativeBalance` / `nativeSymbol` | Current native balance and the chain's real gas token symbol — correct on every chain |
| `ethBalance` | Legacy field, mirrors `nativeBalance` only on Ethereum mainnet (`chainId: 1`); `null` on every other chain, use `nativeBalance`/`nativeSymbol` instead |
| `largeMovements` | Recent successful native transactions at or above `minValueEth`, each with `hash`, `ts`, `direction`, `valueEth`, `counterparty` |
| `tokenTransfers` | Recent ERC-20 transfers (not size-filtered) |
| `movementCount` | Number of large native movements found; `null` (not `0`) when the underlying check failed, so "no movements" and "couldn't check" never look the same |
| `sourceCoverage` / `sourceErrors` | Which underlying checks (balance, nativeTx, tokenTx) succeeded, and why the ones that didn't failed |
| `summary` | Human-readable one-liner |

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [Rug Pull Risk Scorer](https://apify.com/zinin/rug-pull-scorer) | Score ERC-20/BEP-20 token rug-pull risk from honeypot.is simulation + DexScreener liquidity/age |
| [Token Launch Radar](https://apify.com/zinin/token-launch-radar) | Look up any token contract address or ticker across DEXes and get liquidity, 24h volume, pair age, a 0-100… |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |
| [Clinical Trials Monitor](https://apify.com/zinin/clinical-trials-monitor) | Watch conditions, drugs or sponsors for new and updated clinical trials |

### FAQ / Limitations

**Does it need an API key or login?** No — it works out of the box on Ethereum, Optimism, Gnosis, Polygon, Base and Arbitrum via a free, keyless Blockscout explorer. A free Etherscan API key (https://etherscan.io/myapikey) is optional: add one for other chains (e.g. BSC) or for higher throughput than the shared keyless endpoint. If supplied, it's never logged, stored, or included in any output row, even on error.

**How fresh is the data?** Live — every run queries the explorer directly for the latest balance and transaction history.

**Which chains are supported?** Keyless: Ethereum, Optimism, Gnosis, Polygon, Base, Arbitrum. With your own Etherscan API key: any EVM chain on Etherscan's multichain v2 API, including BSC (`chainId: 56`) — that chain is not keyless, a key is required.

**Why does the balance sometimes show a symbol other than ETH?** Because it should — a Polygon wallet holds POL, a BSC wallet holds BNB, not ETH. `nativeSymbol` always names the chain's real gas token; the older `ethBalance` field is kept for backward compatibility but only populated on mainnet.

**Can I call it from an AI agent?** Yes — it's a standard Apify Actor, callable via the Apify API or the Apify MCP server.

**What this is NOT.** A price feed or a trading signal — it reports movements, not a recommendation. Nothing here is financial advice; verify independently before acting on it.

Found a wrong result, or need a chain we don't cover? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

## `wallets` (type: `array`):

Wallet addresses to track (0x... on any EVM chain supported by Etherscan v2). One row per wallet.

## `chainId` (type: `integer`):

EVM chain ID. Keyless (Blockscout) supports 1 = Ethereum, 10 = Optimism, 100 = Gnosis, 137 = Polygon, 8453 = Base, 42161 = Arbitrum. Any other chain needs an Etherscan API key.

## `etherscanApiKey` (type: `string`):

Optional. Leave empty to use a free keyless Blockscout explorer. Provide your own Etherscan key (https://etherscan.io/myapikey) for higher rate limits or a chain not covered keyless. Billed against YOUR quota.

## `minValueEth` (type: `number`):

Flag native transactions moving at least this much ETH (or the chain's native coin) as a "large movement".

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

How many wallets to check in parallel. Keep this low on Etherscan's free tier to avoid rate-limit errors.

## Actor input object example

```json
{
  "wallets": [
    "0x28C6c06298d514Db089934071355E5743bf21d60"
  ],
  "chainId": 1,
  "minValueEth": 1,
  "maxConcurrency": 3
}
```

# 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 = {
    "wallets": [
        "0x28C6c06298d514Db089934071355E5743bf21d60"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/whale-wallet-tracker").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 = { "wallets": ["0x28C6c06298d514Db089934071355E5743bf21d60"] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/whale-wallet-tracker").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 '{
  "wallets": [
    "0x28C6c06298d514Db089934071355E5743bf21d60"
  ]
}' |
apify call zinin/whale-wallet-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/whale-wallet-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whale Wallet Tracker",
        "description": "Track large native ETH and ERC-20 token movements for any wallet(s) via Etherscan's multichain API (bring your own key). Get current balance, flagged transfers above your ETH threshold, and recent token transfer activity — one row per wallet. No RPC node, no wallet-connect, no browser.",
        "version": "0.1",
        "x-build-id": "mPZEjS9I3DAUG85bU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zinin~whale-wallet-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zinin-whale-wallet-tracker",
                "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/zinin~whale-wallet-tracker/runs": {
            "post": {
                "operationId": "runs-sync-zinin-whale-wallet-tracker",
                "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/zinin~whale-wallet-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-zinin-whale-wallet-tracker",
                "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": [
                    "wallets"
                ],
                "properties": {
                    "wallets": {
                        "title": "Wallets",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Wallet addresses to track (0x... on any EVM chain supported by Etherscan v2). One row per wallet.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "chainId": {
                        "title": "Chain ID",
                        "type": "integer",
                        "description": "EVM chain ID. Keyless (Blockscout) supports 1 = Ethereum, 10 = Optimism, 100 = Gnosis, 137 = Polygon, 8453 = Base, 42161 = Arbitrum. Any other chain needs an Etherscan API key.",
                        "default": 1
                    },
                    "etherscanApiKey": {
                        "title": "Etherscan API key (optional)",
                        "type": "string",
                        "description": "Optional. Leave empty to use a free keyless Blockscout explorer. Provide your own Etherscan key (https://etherscan.io/myapikey) for higher rate limits or a chain not covered keyless. Billed against YOUR quota."
                    },
                    "minValueEth": {
                        "title": "Minimum native value (ETH)",
                        "type": "number",
                        "description": "Flag native transactions moving at least this much ETH (or the chain's native coin) as a \"large movement\".",
                        "default": 1
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many wallets to check in parallel. Keep this low on Etherscan's free tier to avoid rate-limit errors.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
