# Hyperliquid Vault Analyzer (`bb-tradetec/hyperliquid-vault-analyzer`) Actor

Screen and rank Hyperliquid vaults by TVL, PnL, age, history coverage, Sharpe, Sortino, drawdown, and a transparent 100-point score.

- **URL**: https://apify.com/bb-tradetec/hyperliquid-vault-analyzer.md
- **Developed by:** [BB](https://apify.com/bb-tradetec) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 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/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 Vault Analyzer

Rank the public Hyperliquid vault universe by TVL, cumulative or window PnL,
age, APR, Sharpe, Sortino, maximum drawdown, and the transparent 100-point
`vault-score-v2` score. Results are written as one structured dataset item per
vault, ready for spreadsheets, dashboards, agents, or scheduled workflows.

> **Unofficial community Actor.** This Actor is not affiliated with, endorsed
> by, sponsored by, or operated by Hyperliquid. Hyperliquid is a third-party
> trademark. The Actor analyzes public data and does not place trades, access a
> wallet, or use private exchange endpoints.

This is historical data analysis, not investment advice, a performance
forecast, or an instruction to deposit into, trade, or copy a vault.

### The vaults, under cold light

At 00:10 UTC, the vaults become numbers. TVL. PnL. Age. Sharpe. Sortino. Some
look expensive. Some merely look successful. The score remembers the
difference.

There are thousands of vaults on the screen and every one of them has a name,
a balance, a history, a leader, a number that wants to be admired. The page is
clean. The money is not.

Once a day, the Hyperliquid Vault Analyzer takes the public universe apart. It
sorts the large from the small, the old from the new, the profitable from the
merely liquid. It measures Sharpe, Sortino, drawdown, coverage and time. Then it
reduces the performance to a transparent score out of one hundred, because the
only thing more seductive than a return is a return with excellent typography.

No wallet. No trade. No prophecy. Just the vaults, ranked under cold light.

### What you can do

- screen the complete prepared universe or up to 1,000 specified vault
  addresses;
- sort high-to-low or low-to-high by score, TVL, all-time cumulative PnL,
  selected-window PnL change, Sharpe, Sortino, age, APR, or name;
- choose 7, 30, 90, 180, or 365-day analysis windows;
- filter by current TVL, vault age, valid-return count, history coverage,
  maximum drawdown, score, Sharpe, Sortino, open/closed state, and score
  eligibility;
- retrieve normalized metadata, daily-history coverage, risk metrics, score
  components, full-universe ranks, and machine-readable warnings;
- return up to 10,000 dataset rows in one run.

### Quick start

The following low-cost query returns 25 open vaults with at least USD 100,000
in current TVL, largest first:

```json
{
  "metricWindow": "30d",
  "minimumTvl": 100000,
  "includeClosed": false,
  "eligibleOnly": false,
  "sortBy": "tvl",
  "sortDirection": "desc",
  "limit": 25
}
````

Leave `vaultAddresses` empty to query all matching prepared vaults. The default
input requests up to 100 open vaults sorted by current TVL and projects 30-day
metrics. This remains useful while the real Sharpe, Sortino, and score history
is still maturing.

Once enough daily history is available, a quality-oriented screen can require
both usable data and explicit risk thresholds:

```json
{
  "metricWindow": "30d",
  "minimumTvl": 100000,
  "minimumAgeDays": 90,
  "minimumReturnCount": 25,
  "minimumCoverageRatio": 0.8,
  "maximumDrawdown": -0.25,
  "minimumScore": 60,
  "minimumSharpeRatio": 1,
  "minimumSortinoRatio": 1,
  "includeClosed": false,
  "sortBy": "score",
  "sortDirection": "desc",
  "limit": 100
}
```

Thresholds are inclusive. Optional score, ratio, and drawdown filters also
exclude rows where the corresponding metric is unavailable; this prevents an
unknown risk value from silently passing a quality screen.

### Input reference

| Field | Type | Default | Contract |
| --- | --- | --- | --- |
| `vaultAddresses` | array of strings | `[]` | Optional EVM-address filter; 0–1,000 unique addresses after trim and lowercase normalization. |
| `metricWindow` | string | `"30d"` | One of `7d`, `30d`, `90d`, `180d`, `365d`. Selects metrics, score, ranks, and `windowPnl`. |
| `minimumTvl` | number | `0` | Minimum current TVL in USD; must be non-negative. |
| `minimumAgeDays` | integer | `0` | Minimum calendar age. A positive threshold excludes unknown ages. |
| `minimumReturnCount` | integer | `0` | Minimum valid daily returns inside `metricWindow`; 0–365. |
| `minimumCoverageRatio` | number | `0` | Minimum valid-return coverage inside `metricWindow`; 0–1. |
| `maximumDrawdown` | optional number | unset | Accepted drawdown floor from -1 to 0. `-0.25` means no worse than -25%; missing drawdown is excluded. |
| `minimumScore` | optional integer | unset | Minimum selected-window score from 0–100; missing score is excluded. |
| `minimumSharpeRatio` | optional number | unset | Minimum selected-window Sharpe; missing Sharpe is excluded. |
| `minimumSortinoRatio` | optional number | unset | Minimum selected-window Sortino; missing Sortino is excluded. |
| `includeClosed` | boolean | `false` | Include closed vaults when `true`. |
| `eligibleOnly` | boolean | `false` | Return only `status: "ok"` rows with a calculable score. |
| `sortBy` | string | `"tvl"` | `score`, `tvl`, `pnl`, `windowPnl`, `sharpe`, `sortino`, `age`, `apr`, or `name`. |
| `sortDirection` | string | `"desc"` | `desc` for highest first; `asc` for lowest first. |
| `limit` | integer | `100` | 1–10,000 dataset rows after filtering and sorting. |

`sortBy: "pnl"` means the latest cumulative all-time PnL supplied by the
discovery feed. `sortBy: "windowPnl"` means `metrics.pnlChange` between the
first and last usable observations in `metricWindow`. Missing sort values are
always placed last in either direction. Equal values are resolved by lowercase
vault address for repeatable output.

### Output reference

Each default-dataset item is a `vaultAnalysis` record with:

- contract metadata: `schemaVersion`, `scoreVersion`, `recordType`, `status`,
  `catalogObservedAt`, `snapshotDate`, `selectedWindow`, and `returnBasis`;
- `vault`: address, name, optional description, leader, creation time, age,
  closed state, relationship, current TVL, current APR, and cumulative PnL;
- history metadata: `historyDayCount` and `maturityBand`;
- `metrics`: coverage, return count, missing days, mean return, volatility,
  Sharpe, Sortino, compounded return, maximum drawdown, positive/negative/flat
  days, PnL change, estimated net flow, and TVL change;
- nullable `score`: overall and five component scores;
- `rank`: full prepared-universe ranks for overall score, TVL, Sharpe, and
  Sortino;
- `warnings`: machine-readable methodology and data-quality flags.

Decimal output values are JSON strings, preserving deterministic decimal
precision. Ratios and percentage returns use fractions: `0.05` means 5%.
Nullable metrics are returned as `null`, never Infinity or NaN.

#### Status values

- `pending`: fewer than 30 valid daily returns;
- `ok`: at least 30 valid returns and all required score inputs are available;
- `ineligible`: at least 30 returns exist, but a required metric or valid vault
  age is unavailable.

The daily collector began building real history on July 18, 2026. There is no
fabricated backfill. A 30-day score therefore requires 31 consecutive usable
snapshots; longer windows mature naturally over time.

### Methodology

For two consecutive UTC snapshots:

```text
daily PnL          = cumulative PnL today - cumulative PnL yesterday
estimated return   = daily PnL / TVL yesterday
estimated net flow = TVL today - TVL yesterday - daily PnL
```

No return is formed across a missing calendar day, when cumulative PnL is
missing, or when previous TVL is non-positive. The result is explicitly
`estimated_daily_pnl_over_previous_tvl`: it is not a verified time-weighted
return or an investable NAV series. Deposits, withdrawals, liquidations, and
changes in upstream methodology can affect interpretation.

Sharpe is the arithmetic daily mean divided by sample standard deviation,
annualized by `sqrt(365)`. Sortino uses a zero daily target and downside
deviation `sqrt(sum(min(0, r)^2) / n)`. Maximum drawdown is computed from the
compounded estimated-return curve. A zero denominator produces `null`.

### Transparent 100-point score

`vault-score-v2` requires at least 30 valid daily returns and all required risk
inputs. Component values use decimal arithmetic and round half up:

| Component | Maximum | Mapping |
| --- | ---: | --- |
| Sharpe | 30 | Linear from Sharpe -1 → 0 points to 3 → 30 points; clamped. |
| Sortino | 25 | Linear from Sortino -1 → 0 points to 5 → 25 points; clamped. |
| Maturity | 20 | Linear from 0 to 365 vault-age days; capped. |
| Liquidity | 15 | Logarithmic from USD 10,000 → 0 points to USD 10,000,000 → 15 points; clamped. |
| Drawdown | 10 | Linear from -50% → 0 points to 0% → 10 points; clamped. |

`overallScore` is the sum of these components. It describes observed public
data, not future quality. It does not measure smart-contract, strategy,
liquidity, leader, custody, or platform risk completely.

### Data freshness and warnings

The internal collector refreshes once per UTC day and keeps the publication
store restricted. This Actor reads only a signed URL for the single prepared
catalog record; it has no access to raw snapshots or other publisher data. A
catalog older than 36 hours adds `stale_catalog` to returned rows.

Common warnings include `estimated_return_not_twr`, `insufficient_history`,
`missing_daily_snapshots`, `missing_cumulative_pnl`,
`missing_or_future_create_time`, `vault_closed`, `extreme_estimated_return`,
`zero_return_volatility`, and `zero_downside_deviation`.

The source discovery feed is public and currently validated in production, but
it is not a stable documented Hyperliquid Info API contract. An upstream schema
change can cause a run to fail safely instead of returning misleading partial
analysis. Descriptions remain `null` when the discovery feed does not supply
them.

### Runtime and cost drivers

Customer runs download one compressed prepared catalog and perform local
filtering and sorting. They do not request thousands of vault detail endpoints
or rebuild 365 days of history. Runtime and platform usage mainly grow with the
requested output `limit`; start with 25–100 rows before requesting the full
universe. Check the Actor's current Pricing tab for the applicable Apify usage
model.

### Privacy and support

Inputs contain only public vault addresses and query settings. The Actor does
not request wallet keys, signatures, exchange credentials, or personal data.
For a reproducible problem, open the Actor's **Issues** tab and include the run
ID, input with secrets removed, expected result, and observed result.

# Actor input Schema

## `vaultAddresses` (type: `array`):

Optional address filter. Leave empty to query the complete prepared universe.

## `metricWindow` (type: `string`):

Daily return window used for ratios, score, ranking, and output.

## `minimumTvl` (type: `number`):

Exclude vaults below this current public TVL value.

## `minimumAgeDays` (type: `integer`):

Exclude vaults younger than this many calendar days. A positive value also excludes vaults with unknown age.

## `minimumReturnCount` (type: `integer`):

Require at least this many valid daily returns inside the selected metric window.

## `minimumCoverageRatio` (type: `number`):

Require valid-return coverage from 0 to 1 inside the selected metric window; 0.8 means 80%.

## `maximumDrawdown` (type: `number`):

Optional negative fractional threshold. For example, -0.25 keeps vaults with a calculated maximum drawdown no worse than -25% and excludes missing values.

## `minimumScore` (type: `integer`):

Optional 0-100 score threshold. Setting it excludes vaults whose selected-window score is unavailable.

## `minimumSharpeRatio` (type: `number`):

Optional selected-window Sharpe threshold. Setting it excludes vaults whose Sharpe ratio is unavailable.

## `minimumSortinoRatio` (type: `number`):

Optional selected-window Sortino threshold. Setting it excludes vaults whose Sortino ratio is unavailable.

## `includeClosed` (type: `boolean`):

Closed vaults are excluded by default.

## `eligibleOnly` (type: `boolean`):

Return only vaults with at least 30 valid daily returns and a calculable score.

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

Field used to order matching vaults. PnL means the latest cumulative all-time PnL; window PnL is its change over the selected metric window. Unavailable values are placed last.

## `sortDirection` (type: `string`):

Order available sort values from highest to lowest or lowest to highest.

## `limit` (type: `integer`):

Maximum number of matching vault rows written to the dataset.

## Actor input object example

```json
{
  "vaultAddresses": [],
  "metricWindow": "30d",
  "minimumTvl": 0,
  "minimumAgeDays": 0,
  "minimumReturnCount": 0,
  "minimumCoverageRatio": 0,
  "includeClosed": false,
  "eligibleOnly": false,
  "sortBy": "tvl",
  "sortDirection": "desc",
  "limit": 100
}
```

# Actor output Schema

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

Filtered and ranked vault analysis records from the default dataset.

# 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-vault-analyzer").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-vault-analyzer").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-vault-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hyperliquid Vault Analyzer",
        "description": "Screen and rank Hyperliquid vaults by TVL, PnL, age, history coverage, Sharpe, Sortino, drawdown, and a transparent 100-point score.",
        "version": "0.3",
        "x-build-id": "xHu8oC1D6n8xHSb7y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bb-tradetec~hyperliquid-vault-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bb-tradetec-hyperliquid-vault-analyzer",
                "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-vault-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-bb-tradetec-hyperliquid-vault-analyzer",
                "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-vault-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-bb-tradetec-hyperliquid-vault-analyzer",
                "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": {
                    "vaultAddresses": {
                        "title": "Vault addresses (optional)",
                        "maxItems": 1000,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional address filter. Leave empty to query the complete prepared universe.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\s*0x[a-fA-F0-9]{40}\\s*$"
                        },
                        "default": []
                    },
                    "metricWindow": {
                        "title": "Metric window",
                        "enum": [
                            "7d",
                            "30d",
                            "90d",
                            "180d",
                            "365d"
                        ],
                        "type": "string",
                        "description": "Daily return window used for ratios, score, ranking, and output.",
                        "default": "30d"
                    },
                    "minimumTvl": {
                        "title": "Minimum current TVL (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Exclude vaults below this current public TVL value.",
                        "default": 0
                    },
                    "minimumAgeDays": {
                        "title": "Minimum vault age (days)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude vaults younger than this many calendar days. A positive value also excludes vaults with unknown age.",
                        "default": 0
                    },
                    "minimumReturnCount": {
                        "title": "Minimum valid daily returns",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Require at least this many valid daily returns inside the selected metric window.",
                        "default": 0
                    },
                    "minimumCoverageRatio": {
                        "title": "Minimum history coverage",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Require valid-return coverage from 0 to 1 inside the selected metric window; 0.8 means 80%.",
                        "default": 0
                    },
                    "maximumDrawdown": {
                        "title": "Maximum accepted drawdown",
                        "minimum": -1,
                        "maximum": 0,
                        "type": "number",
                        "description": "Optional negative fractional threshold. For example, -0.25 keeps vaults with a calculated maximum drawdown no worse than -25% and excludes missing values."
                    },
                    "minimumScore": {
                        "title": "Minimum overall score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Optional 0-100 score threshold. Setting it excludes vaults whose selected-window score is unavailable."
                    },
                    "minimumSharpeRatio": {
                        "title": "Minimum Sharpe ratio",
                        "type": "number",
                        "description": "Optional selected-window Sharpe threshold. Setting it excludes vaults whose Sharpe ratio is unavailable."
                    },
                    "minimumSortinoRatio": {
                        "title": "Minimum Sortino ratio",
                        "type": "number",
                        "description": "Optional selected-window Sortino threshold. Setting it excludes vaults whose Sortino ratio is unavailable."
                    },
                    "includeClosed": {
                        "title": "Include closed vaults",
                        "type": "boolean",
                        "description": "Closed vaults are excluded by default.",
                        "default": false
                    },
                    "eligibleOnly": {
                        "title": "Only scored vaults",
                        "type": "boolean",
                        "description": "Return only vaults with at least 30 valid daily returns and a calculable score.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "score",
                            "tvl",
                            "pnl",
                            "windowPnl",
                            "sharpe",
                            "sortino",
                            "age",
                            "apr",
                            "name"
                        ],
                        "type": "string",
                        "description": "Field used to order matching vaults. PnL means the latest cumulative all-time PnL; window PnL is its change over the selected metric window. Unavailable values are placed last.",
                        "default": "tvl"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Order available sort values from highest to lowest or lowest to highest.",
                        "default": "desc"
                    },
                    "limit": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching vault rows written to the dataset.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
