# ETHUSDT Smart Alert Bot (`metal_beetroot/ethusdt-smart-alert-bot`) Actor

Monitors Binance ETHUSDT pair for Volume Spikes, Price Drops, and Trailing Stop-loss breaches. Sends real-time Telegram alerts and logs every trigger to the Dataset.

- **URL**: https://apify.com/metal\_beetroot/ethusdt-smart-alert-bot.md
- **Developed by:** [G Han](https://apify.com/metal_beetroot) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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

## 🔔 ETHUSDT Smart Alert Bot

> **Real-time crypto market monitoring on Apify.** Track Binance trading pairs for Volume Spikes, Price Drops, and Trailing Stop-loss Breaches – with instant Telegram notifications.

---

### 🎯 What does this Actor do?

This Actor connects to the **Binance public API** (no API key required) and monitors any supported trading pair (default: `ETHUSDT`) for three configurable market conditions:

| Alert Type | Description |
|---|---|
| **📊 Volume Spike** | Fires when the 24-hour trading volume surges above a configurable threshold compared to the previous run's volume. |
| **🔻 Price Drop** | Fires when the 24-hour price change percentage drops below a negative threshold (e.g., -5%). |
| **🛑 Trailing Stop-loss Breach** | Tracks the highest recorded price (high watermark) across runs. Fires when the price retraces from the peak by more than the configured trailing stop distance. |

When a condition is met, the bot:
1. **Sends a formatted Telegram message** with all relevant details.
2. **Pushes a JSON record** to the Apify Dataset for logging and export (CSV/JSON/Excel).

#### Key Features

- ✅ **Stateful across runs** – Remembers the high watermark and previous volume via Apify Key-Value Store.
- ✅ **Zero API keys** – Uses Binance's public endpoint (no authentication needed).
- ✅ **Lightweight** – Direct API calls via Axios, no browser or headless Chrome required.
- ✅ **Dry Run mode** – Test your configuration without sending Telegram messages.
- ✅ **Schedule-ready** – Designed to run on a cron schedule (e.g., every 5 minutes).

---

### 📥 Input Configuration

| Field | Type | Default | Required | Description |
|---|---|---|---|---|
| `tradingPair` | `string` | `ETHUSDT` | No | Binance trading pair symbol |
| `alertType` | `enum` | `All` | No | `Volume Spike`, `Price Drop`, `Trailing Stop-loss Breach`, or `All` |
| `thresholdPercentage` | `number` | `5` | No | % change to trigger Volume Spike / Price Drop |
| `trailingStopDistance` | `number` | `3` | No | % drop from peak to trigger Trailing Stop-loss |
| `telegramBotToken` | `string` | — | **Yes*** | Telegram Bot API token |
| `telegramChatId` | `string` | — | **Yes*** | Telegram chat/group/channel ID |
| `enableDryRun` | `boolean` | `false` | No | Skip Telegram delivery (for testing) |

> *\*Required when `enableDryRun` is `false`.*

#### Example Input (JSON)

```json
{
    "tradingPair": "ETHUSDT",
    "alertType": "All",
    "thresholdPercentage": 5,
    "trailingStopDistance": 3,
    "telegramBotToken": "123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ",
    "telegramChatId": "-1001234567890",
    "enableDryRun": false
}
````

***

### 📤 Output

#### Dataset Record Schema

Every triggered alert pushes a record to the default **Apify Dataset**. You can download the full log as JSON, CSV, or Excel from the Actor Run page.

```json
{
    "timestamp": "2026-04-30T14:30:00.000Z",
    "pair": "ETHUSDT",
    "currentPrice": 1842.55,
    "triggerReason": "Volume Spike",
    "priceChangePct24h": 2.34,
    "volume24h": 125430.12,
    "volumeChangePct": 8.72,
    "highWatermark": 1900.00,
    "thresholdPct": 5
}
```

#### Telegram Message Example

```
📊 ALERT – VOLUME SPIKE

Pair:        ETHUSDT
Price:       $1,842.55
24h Change:  +2.34%
24h Volume:  125.43K
Threshold:   5%

🕒 2026-04-30T14:30:00.000Z
```

***

### 🤖 How to get your Telegram Bot Token

1. Open Telegram and search for **@BotFather**.
2. Send `/newbot` and follow the instructions.
3. BotFather will give you a token like `123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ`.
4. Copy this token and paste it in the `telegramBotToken` input field.

#### How to find your Chat ID

1. **Start a conversation** with your new bot (send any message).
2. Open this URL in your browser (replace `<TOKEN>` with your bot token):
   ```
   https://api.telegram.org/bot<TOKEN>/getUpdates
   ```
3. Look for `"chat":{"id": 123456789, ...}` in the JSON response.
4. Copy the numeric `id` and paste it in the `telegramChatId` input field.

> **Tip:** For group chats, add the bot to the group, send a message mentioning the bot, and repeat step 2. Group IDs are negative numbers (e.g., `-1001234567890`).

***

### ⏰ Recommended Schedule

For optimal monitoring, schedule this Actor to run on a short interval:

| Use Case | Cron Expression | Frequency |
|---|---|---|
| Active trading | `*/5 * * * *` | Every 5 minutes |
| Swing trading | `*/30 * * * *` | Every 30 minutes |
| Daily check | `0 */4 * * *` | Every 4 hours |
| Low-cost monitoring | `0 0 * * *` | Once a day |

> **Cost note:** Each run uses only **~32 MB RAM** and completes in **< 5 seconds** (API call only, no browser). At the 5-minute interval, monthly cost is approximately **$1–2** on the Apify platform.

***

### 🏗️ Architecture

```
┌──────────────────────────────┐
│         Apify Scheduler      │
│      (cron: */5 * * * *)     │
└──────────┬───────────────────┘
           │ triggers
           ▼
┌──────────────────────────────┐
│     ETHUSDT Smart Alert Bot  │
│                              │
│  1. Load state (KV Store)    │
│  2. GET /api/v3/ticker/24hr  │──► Binance API
│  3. Evaluate conditions      │
│  4. Push alerts → Dataset    │──► Apify Dataset (CSV/JSON)
│  5. Send alerts → Telegram   │──► Telegram Bot API
│  6. Save state (KV Store)    │
└──────────────────────────────┘
```

#### State Persistence

The Actor uses the **Apify Key-Value Store** to persist state across runs:

| Key | Description |
|---|---|
| `highWatermark` | Highest price recorded since last Trailing Stop breach |
| `previousVolume24h` | 24h volume from the previous run (for spike comparison) |
| `lastPrice` | Last observed price |
| `lastCheckedAt` | ISO timestamp of the last successful check |

***

### 🔧 Local Development

```bash
## Clone the repo
git clone <repo-url>
cd ethusdt-smart-alert-bot

## Install dependencies
npm install

## Create local input
mkdir -p storage/key_value_stores/default
cat > storage/key_value_stores/default/INPUT.json << 'EOF'
{
    "tradingPair": "ETHUSDT",
    "alertType": "All",
    "thresholdPercentage": 2,
    "trailingStopDistance": 3,
    "enableDryRun": true
}
EOF

## Run locally
npm start
```

***

### 📜 Changelog

#### v1.0.0

- Initial release.
- Volume Spike, Price Drop, and Trailing Stop-loss Breach detection.
- Telegram HTML alerts.
- Apify Dataset logging.
- Stateful Key-Value Store persistence.

***

### 📄 License

ISC © CryptoDevLabs

# Actor input Schema

## `tradingPair` (type: `string`):

The Binance trading pair symbol to monitor (e.g. ETHUSDT, BTCUSDT, SOLUSDT). Must match a valid Binance symbol.

## `alertType` (type: `string`):

Choose which type of market event should trigger an alert.

• **Volume Spike** – fires when 24h volume surges above the threshold.
• **Price Drop** – fires when the 24h price change drops below the negative threshold.
• **Trailing Stop-loss Breach** – fires when the price falls from its recorded high watermark by more than the trailing stop distance.
• **All** – monitors all three conditions simultaneously.

## `thresholdPercentage` (type: `number`):

The percentage change that triggers a Volume Spike or Price Drop alert.

For **Volume Spike**: alert fires when current 24h volume exceeds the previous 24h average volume by this percentage.
For **Price Drop**: alert fires when 24h price change is worse than –(threshold)%.

Example: set to 5 to trigger when volume spikes by 5% or price drops by 5%.

## `trailingStopDistance` (type: `number`):

Percentage drop from the highest recorded price (high watermark) that triggers a Trailing Stop-loss Breach alert.

The bot remembers the all-time high price across runs. When the current price falls below `highWatermark × (1 – trailingStopDistance / 100)`, an alert is sent and the high watermark resets.

Example: set to 3 to be alerted when the price retraces 3% from its peak.

## `telegramBotToken` (type: `string`):

The HTTP API token for your Telegram Bot. You can create one by talking to @BotFather on Telegram.

Format: `123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ`

## `telegramChatId` (type: `string`):

The numeric Chat ID where alerts will be sent. This can be a personal chat, group, or channel.

To find your Chat ID, send a message to your bot, then visit:
`https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates`
and look for `"chat":{"id": ...}`.

## `enableDryRun` (type: `boolean`):

When enabled, the bot will evaluate all conditions and push records to the Dataset, but will NOT send Telegram messages. Useful for testing your configuration.

## Actor input object example

```json
{
  "tradingPair": "ETHUSDT",
  "alertType": "All",
  "thresholdPercentage": 5,
  "trailingStopDistance": 3,
  "enableDryRun": false
}
```

# 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 = {
    "tradingPair": "ETHUSDT",
    "thresholdPercentage": 5,
    "trailingStopDistance": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("metal_beetroot/ethusdt-smart-alert-bot").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 = {
    "tradingPair": "ETHUSDT",
    "thresholdPercentage": 5,
    "trailingStopDistance": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("metal_beetroot/ethusdt-smart-alert-bot").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 '{
  "tradingPair": "ETHUSDT",
  "thresholdPercentage": 5,
  "trailingStopDistance": 3
}' |
apify call metal_beetroot/ethusdt-smart-alert-bot --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=metal_beetroot/ethusdt-smart-alert-bot",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ETHUSDT Smart Alert Bot",
        "description": "Monitors Binance ETHUSDT pair for Volume Spikes, Price Drops, and Trailing Stop-loss breaches. Sends real-time Telegram alerts and logs every trigger to the Dataset.",
        "version": "0.0",
        "x-build-id": "rpTcsoiudeh079eZr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/metal_beetroot~ethusdt-smart-alert-bot/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-metal_beetroot-ethusdt-smart-alert-bot",
                "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/metal_beetroot~ethusdt-smart-alert-bot/runs": {
            "post": {
                "operationId": "runs-sync-metal_beetroot-ethusdt-smart-alert-bot",
                "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/metal_beetroot~ethusdt-smart-alert-bot/run-sync": {
            "post": {
                "operationId": "run-sync-metal_beetroot-ethusdt-smart-alert-bot",
                "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": {
                    "tradingPair": {
                        "title": "Trading Pair",
                        "type": "string",
                        "description": "The Binance trading pair symbol to monitor (e.g. ETHUSDT, BTCUSDT, SOLUSDT). Must match a valid Binance symbol.",
                        "default": "ETHUSDT"
                    },
                    "alertType": {
                        "title": "Alert Type",
                        "enum": [
                            "Volume Spike",
                            "Price Drop",
                            "Trailing Stop-loss Breach",
                            "All"
                        ],
                        "type": "string",
                        "description": "Choose which type of market event should trigger an alert.\n\n• **Volume Spike** – fires when 24h volume surges above the threshold.\n• **Price Drop** – fires when the 24h price change drops below the negative threshold.\n• **Trailing Stop-loss Breach** – fires when the price falls from its recorded high watermark by more than the trailing stop distance.\n• **All** – monitors all three conditions simultaneously.",
                        "default": "All"
                    },
                    "thresholdPercentage": {
                        "title": "Threshold Percentage (%)",
                        "minimum": 0.1,
                        "maximum": 100,
                        "type": "number",
                        "description": "The percentage change that triggers a Volume Spike or Price Drop alert.\n\nFor **Volume Spike**: alert fires when current 24h volume exceeds the previous 24h average volume by this percentage.\nFor **Price Drop**: alert fires when 24h price change is worse than –(threshold)%.\n\nExample: set to 5 to trigger when volume spikes by 5% or price drops by 5%.",
                        "default": 5
                    },
                    "trailingStopDistance": {
                        "title": "Trailing Stop Distance (%)",
                        "minimum": 0.1,
                        "maximum": 50,
                        "type": "number",
                        "description": "Percentage drop from the highest recorded price (high watermark) that triggers a Trailing Stop-loss Breach alert.\n\nThe bot remembers the all-time high price across runs. When the current price falls below `highWatermark × (1 – trailingStopDistance / 100)`, an alert is sent and the high watermark resets.\n\nExample: set to 3 to be alerted when the price retraces 3% from its peak.",
                        "default": 3
                    },
                    "telegramBotToken": {
                        "title": "Telegram Bot Token",
                        "type": "string",
                        "description": "The HTTP API token for your Telegram Bot. You can create one by talking to @BotFather on Telegram.\n\nFormat: `123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ`"
                    },
                    "telegramChatId": {
                        "title": "Telegram Chat ID",
                        "type": "string",
                        "description": "The numeric Chat ID where alerts will be sent. This can be a personal chat, group, or channel.\n\nTo find your Chat ID, send a message to your bot, then visit:\n`https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates`\nand look for `\"chat\":{\"id\": ...}`."
                    },
                    "enableDryRun": {
                        "title": "Dry Run (no Telegram)",
                        "type": "boolean",
                        "description": "When enabled, the bot will evaluate all conditions and push records to the Dataset, but will NOT send Telegram messages. Useful for testing your configuration.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```