# Hyperliquid Swing & Breakout Scanner (`bb-tradetec/hyperliquid-swing-breakout-scanner`) Actor

Scan selected or all active Hyperliquid perpetual markets for confirmed close-based swing breakouts, grouped events, volume context, and active levels.

- **URL**: https://apify.com/bb-tradetec/hyperliquid-swing-breakout-scanner.md
- **Developed by:** [BB](https://apify.com/bb-tradetec) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 analyzed hyperliquid markets

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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Hyperliquid Swing & Breakout Scanner

> **Unofficial community project.** This Actor is not affiliated with,
> sponsored by, or endorsed by Hyperliquid. Hyperliquid is a third-party data
> source accessed through its public API.

List active Hyperliquid perpetual symbols, scan a watchlist of up to 20 markets,
or scan every active standard perpetual in one run for confirmed swing levels
and fresh close-based breakouts. Results include both
deterministic level events and a decision-ready summary with grouped breakout
candles, direction counts, active levels, volume context, and candle metrics.

The Actor uses public Hyperliquid data. It requires no wallet, private exchange
API key, proxy, database, or always-on server.

This is an analytical data tool, not financial advice. It does not place
trades, predict future prices, or guarantee outcomes.

### Why use this Actor?

Breakout charts are easy to inspect one at a time, but harder to turn into a
repeatable data workflow. Open candles can create premature signals, pivots can
appear earlier than they were actually confirmable, and one candle crossing
several older levels can make a market look busier than it was.

This Actor handles those edge cases and returns transparent measurements rather
than an opaque signal score:

- scan a small watchlist or the complete active standard-perpetual universe;
- distinguish broken levels from unique breakout candles;
- compare breakout volume and candle structure without extra data calls;
- inspect nearby unbroken swing levels and deterministic event IDs;
- keep successful markets when another symbol returns a temporary data error.

The structured output is suited to research, alerts, dashboards, scheduled
monitoring, webhooks, and other automation where reproducible event rules matter.

### Operations

The Actor uses the standard Apify input and default dataset. There is no custom
HTTP endpoint.

- `listSymbols` returns active standard perpetual names from Hyperliquid's first
  perpetual DEX. Delisted, spot, and HIP-3 markets are excluded.
- `scanBreakouts` returns one result row per requested symbol. It is the default
  operation. Set `scanAllSymbols: true` to resolve and scan the complete active
  first-DEX perpetual universe automatically.

List symbols:

```json
{
  "operation": "listSymbols"
}
````

Scan breakouts:

```json
{
  "operation": "scanBreakouts",
  "scanAllSymbols": false,
  "symbols": ["BTC", "ETH", "SOL"],
  "interval": "1h",
  "candleCount": 300,
  "pivotStrength": 3,
  "breakoutLookbackCandles": 20,
  "direction": "both"
}
```

Scan all active symbols without preparing or batching a symbol list:

```json
{
  "operation": "scanBreakouts",
  "scanAllSymbols": true,
  "interval": "1h",
  "candleCount": 300,
  "pivotStrength": 3,
  "breakoutLookbackCandles": 20,
  "direction": "both"
}
```

Complete-market runs pace candle requests according to Hyperliquid's documented
IP-based request weights. This trades a few minutes of runtime for materially
fewer rate-limit errors; a manual watchlist is not given this additional delay.

#### API example

For a synchronous watchlist request that returns dataset items directly:

```bash
curl -X POST \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "operation": "scanBreakouts",
    "symbols": ["BTC", "ETH", "SOL"],
    "interval": "1h",
    "candleCount": 300,
    "pivotStrength": 3,
    "breakoutLookbackCandles": 20,
    "direction": "both"
  }' \
  'https://api.apify.com/v2/acts/bb-tradetec~hyperliquid-swing-breakout-scanner/run-sync-get-dataset-items'
```

Use the asynchronous `/runs` endpoint for workflows that should not keep the
client connection open while a complete-market scan is running.

### Detection rules

A swing uses a strict, symmetric pivot rule. With `pivotStrength = 3`, a swing
high must be strictly above the three candles on each side; a swing low must be
strictly below them. Equal highs or lows disqualify the pivot.

The pivot becomes usable only after its full right-side window has closed.
`pivotTime` identifies the central candle, while `confirmedAt` or
`pivotConfirmedAt` identifies when the level actually became observable.

A bullish breakout requires a later closed candle with
`close > swingHighLevel`. A bearish breakout requires
`close < swingLowLevel`. Wick-only moves and closes exactly on the level do not
count. Each level creates at most one event. One candle may break several older
levels.

Only candles closed by the captured run time are analysed. The Actor uses exact
decimal comparisons and does not move confirmations backward in time.

### Input

| Field | Default | Limits | Meaning |
|---|---:|---|---|
| `operation` | `scanBreakouts` | `scanBreakouts`, `listSymbols` | Selects the operation. Scan fields are ignored by `listSymbols`. |
| `scanAllSymbols` | `false` | `true`, `false` | For `scanBreakouts`, fetches and scans every currently active standard perpetual. When `true`, `symbols` is ignored. |
| `symbols` | `BTC`, `ETH`, `SOL` | 1–20 | Manual watchlist used when `scanAllSymbols` is `false`. |
| `interval` | `1h` | `5m`, `15m`, `30m`, `1h`, `4h`, `1d` | One timeframe per run. |
| `candleCount` | 300 | 50–500 | Recent closed candles requested per symbol. |
| `pivotStrength` | 3 | 1–10 | Strict candles required on both sides of a pivot. |
| `breakoutLookbackCandles` | 20 | 1–200, no greater than `candleCount` | Maximum returned breakout age. `1` means the newest closed candle only. |
| `direction` | `both` | `both`, `bullish`, `bearish` | Filters returned events and grouped breakout summaries. |

Common symbol names are trimmed and uppercased. Hyperliquid names with a
lowercase `k` prefix retain that prefix. If fewer usable candles than requested
are available, the result contains a warning. After a data gap, only the newest
contiguous candle segment is analysed.

### Output

The output contract is `schemaVersion: "1.1"`. Breakout detection remains
`engineVersion: "swing-breakout-v1"`.

A successful `scanBreakouts` row contains:

- latest closed candle and latest confirmed swing high and low;
- `breakouts`: one detailed event per broken level;
- `summary`: grouped and contextual views derived from the same data;
- counts, warnings, and scan metadata.

The eight summary views are:

1. broken level count, unique breakout candle count, and maximum levels broken
   by one candle;
2. latest grouped breakout;
3. bullish and bearish totals for both levels and unique candles;
4. nearest unbroken swing high and swing low, with distance and age;
5. pivot age when each breakout occurred;
6. breakout volume and trades versus median volume of up to 20 prior candles;
7. candle range, body share, and close position;
8. one chronological group per breakout candle with all crossed levels.

These summaries require no additional network call. The detailed `breakouts`
array remains available for granular event processing and deterministic
deduplication.

#### Important field semantics

- `ageCandles`: closed candles since the breakout; `0` is the newest candle.
- `pivotAgeAtBreakoutCandles`: candles from pivot confirmation to breakout;
  the first eligible candle is `1`.
- `distancePct`: absolute close-to-level distance; it is not a quality score.
- `volumeRatio`: breakout volume divided by median volume of up to 20
  immediately preceding candles. The breakout candle is excluded.
- `rangePct`: candle range divided by open price.
- `bodyPctOfRange`: absolute candle body divided by range.
- `closePositionPct`: close position from low (`0`) to high (`100`).
- `nearestActiveSwingHigh` and `nearestActiveSwingLow`: closest unbroken levels
  to the latest close, independent of the breakout direction filter.

Prices, volumes, ratios, and percentages are serialized as decimal strings to
preserve precision. Percentages are rounded to six decimal places and rendered
without unnecessary trailing zeroes.

The Actor's Input, API, and Dataset tabs expose the complete machine-readable
contracts. The Dataset tab also provides separate table views for scan results
and available symbols.

#### Errors

A symbol-level failure uses `status: "error"`, `summary: null`, and a structured
`error` object without removing successful rows for other symbols. Stable codes
include `http_error`, `rate_limited`, `network_error`, `invalid_response`,
`no_candles`, `insufficient_closed_data`, `insufficient_contiguous_data`, and
`conflicting_duplicate_candle`.

The run fails only if no requested symbol produces a successful result; the
error rows are stored first.

### Using the results

Read results from the default dataset through the Apify Console, Actor API,
client libraries, integrations, or export endpoints. Typical uses include:

- watchlists and monitoring dashboards;
- notification and webhook workflows;
- reproducible research datasets;
- scheduled cross-market scans;
- downstream ranking with user-defined criteria.

The Actor deliberately provides transparent measurements rather than an opaque
signal-quality or profitability score.

### Local development

Python 3.13 is required.

```bash
python3.13 -m venv .venv
. .venv/bin/activate
python -m pip install -e '.[dev]'
python -m pytest --cov=hyperliquid_scanner --cov-report=term-missing
ruff check .
ruff format --check .
mypy src
apify validate-schema
apify run
```

The release container installs the hash-locked third-party Python 3.13 Linux
dependency set from `pylock.toml`, then installs the local package without
re-resolving dependencies. `pyproject.toml` retains compatible version ranges
for editable development installs.

The normal test suite is offline. The separate public API smoke test is opt-in:

```bash
RUN_LIVE_TESTS=1 python -m pytest -m live
```

Local Actor input is read from
`storage/key_value_stores/default/INPUT.json`. Runtime dataset files are ignored
project artifacts.

### Contracts and versioning

Actor `0.4` adds automatic all-symbol scanning while preserving the manual
watchlist mode. Actor `0.3` added derived summaries and context. Both retain the
`swing-breakout-v1` detection rule; symbol discovery was introduced in Actor
`0.2`.

# Actor input Schema

## `operation` (type: `string`):

List all active first-DEX perpetual symbols, or run the swing and breakout scan. Scan parameters are ignored when listing symbols.

## `scanAllSymbols` (type: `boolean`):

For scanBreakouts: fetch and scan every active first-DEX perpetual symbol. When enabled, the manual symbols list is ignored. Candle requests use bounded concurrency and rate-aware pacing, so a complete-market run takes longer than a watchlist run.

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

For scanBreakouts when Scan all active symbols is disabled: one to twenty first-DEX perpetual symbols, for example BTC, ETH, or kPEPE. Spot and HIP-3 symbols are not supported.

## `interval` (type: `string`):

Exactly one timeframe per run.

## `candleCount` (type: `integer`):

The most recent closed candles requested per symbol. Fewer may be returned for a newer market.

## `pivotStrength` (type: `integer`):

Number of strict lower/higher candles required on both sides of a swing pivot.

## `breakoutLookbackCandles` (type: `integer`):

Only output breakouts from this many most recent closed candles. A value of 1 means the latest closed candle only.

## `direction` (type: `string`):

Filters only the returned breakouts; all swing levels are still evaluated.

## Actor input object example

```json
{
  "operation": "scanBreakouts",
  "scanAllSymbols": false,
  "symbols": [
    "BTC",
    "ETH",
    "SOL"
  ],
  "interval": "1h",
  "candleCount": 300,
  "pivotStrength": 3,
  "breakoutLookbackCandles": 20,
  "direction": "both"
}
```

# Actor output Schema

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

The default dataset containing either the available-symbol list or schema-version 1.1 scan records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bb-tradetec/hyperliquid-swing-breakout-scanner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("bb-tradetec/hyperliquid-swing-breakout-scanner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call bb-tradetec/hyperliquid-swing-breakout-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bb-tradetec/hyperliquid-swing-breakout-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hyperliquid Swing & Breakout Scanner",
        "description": "Scan selected or all active Hyperliquid perpetual markets for confirmed close-based swing breakouts, grouped events, volume context, and active levels.",
        "version": "0.4",
        "x-build-id": "LdMte2tmYgdYbfB0q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bb-tradetec~hyperliquid-swing-breakout-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bb-tradetec-hyperliquid-swing-breakout-scanner",
                "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/bb-tradetec~hyperliquid-swing-breakout-scanner/runs": {
            "post": {
                "operationId": "runs-sync-bb-tradetec-hyperliquid-swing-breakout-scanner",
                "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/bb-tradetec~hyperliquid-swing-breakout-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-bb-tradetec-hyperliquid-swing-breakout-scanner",
                "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": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "scanBreakouts",
                            "listSymbols"
                        ],
                        "type": "string",
                        "description": "List all active first-DEX perpetual symbols, or run the swing and breakout scan. Scan parameters are ignored when listing symbols.",
                        "default": "scanBreakouts"
                    },
                    "scanAllSymbols": {
                        "title": "Scan all active symbols",
                        "type": "boolean",
                        "description": "For scanBreakouts: fetch and scan every active first-DEX perpetual symbol. When enabled, the manual symbols list is ignored. Candle requests use bounded concurrency and rate-aware pacing, so a complete-market run takes longer than a watchlist run.",
                        "default": false
                    },
                    "symbols": {
                        "title": "Perpetual symbols",
                        "minItems": 1,
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "For scanBreakouts when Scan all active symbols is disabled: one to twenty first-DEX perpetual symbols, for example BTC, ETH, or kPEPE. Spot and HIP-3 symbols are not supported.",
                        "items": {
                            "type": "string",
                            "pattern": "^(?:[A-Za-z0-9]+|k[A-Za-z0-9]+)$"
                        },
                        "default": [
                            "BTC",
                            "ETH",
                            "SOL"
                        ]
                    },
                    "interval": {
                        "title": "Candle interval",
                        "enum": [
                            "5m",
                            "15m",
                            "30m",
                            "1h",
                            "4h",
                            "1d"
                        ],
                        "type": "string",
                        "description": "Exactly one timeframe per run.",
                        "default": "1h"
                    },
                    "candleCount": {
                        "title": "Closed candles to scan",
                        "minimum": 50,
                        "maximum": 500,
                        "type": "integer",
                        "description": "The most recent closed candles requested per symbol. Fewer may be returned for a newer market.",
                        "default": 300
                    },
                    "pivotStrength": {
                        "title": "Pivot strength",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of strict lower/higher candles required on both sides of a swing pivot.",
                        "default": 3
                    },
                    "breakoutLookbackCandles": {
                        "title": "Fresh-breakout lookback",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Only output breakouts from this many most recent closed candles. A value of 1 means the latest closed candle only.",
                        "default": 20
                    },
                    "direction": {
                        "title": "Output direction",
                        "enum": [
                            "both",
                            "bullish",
                            "bearish"
                        ],
                        "type": "string",
                        "description": "Filters only the returned breakouts; all swing levels are still evaluated.",
                        "default": "both"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```