# 🪙 Crypto Top 100 Screener — Market Cap, Volume, ATH (`nexgendata/crypto-top100-screener`) Actor

Track top 100 cryptocurrencies by market cap: Bitcoin, Ethereum, Solana, plus DeFi, Layer 2, and altcoins. Real-time prices, 24h/7d/30d/YTD performance, supply data, all-time-high tracking. CoinGecko-quality data for crypto funds, DeFi, market makers, treasury teams, fintech. Pay-per-result.

- **URL**: https://apify.com/nexgendata/crypto-top100-screener.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 crypto records

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

## 🪙 Crypto Top 100 Screener — Market Cap, Volume, ATH & DeFi/L2 Categories

Track the **top 100 cryptocurrencies by market cap** with one API call. Real-time spot prices, 24h / 7d / 30d / YTD performance windows, full supply data, all-time-high and all-time-low context, and curated category classification (Layer 1, Layer 2, DeFi, Meme, Stablecoin, Exchange Token, Privacy, Gaming, AI, RWA). Built on CoinGecko's free public markets endpoint and normalized for institutional consumption.

Designed for **crypto-native funds and traditional fintech teams** that need a single, deterministic, schema-stable feed of the crypto market — **no API keys to rotate, no rate-limit math, no SDK to ingest**.

---

### Why this beats CoinGecko Pro, CoinMarketCap Pro, Messari & Kaiko

- **Pay-per-result, not per-month.** A full Top 100 daily snapshot costs **$5.01** end-to-end. CoinGecko Pro Analyst is **$129/mo minimum**, CoinMarketCap Pro Hobbyist is **$333/mo**, Messari Pro starts around **$2,000/mo**. If you only need a daily Top 100 with category tags, you are radically over-paying.
- **No API key, no SDK, no quota math.** Just `apify call` and a JSON payload. Built-in retry + backoff handles CoinGecko 429s for you; you never see them.
- **Schema-stable contract.** This README *is* the contract. CoinGecko Pro and CoinMarketCap have shipped breaking field changes; we normalize against them. Every record has the same 22 fields, every run, every day.
- **Buyer-aware classification.** Layer 1 vs Layer 2 vs DeFi vs Meme vs Stablecoin vs Exchange vs Privacy vs Gaming vs AI vs RWA — curated symbol map maintained against on-chain reality, not a stale taxonomy endpoint.
- **Filterable in one input.** Drop stablecoins, drop memes, restrict to DeFi, set a market-cap floor — all five filters compose in one JSON object. No client-side pandas required.

---

### What You Get (per record)

| Bucket | Fields |
|---|---|
| **Identity** | `symbol` (BTC, ETH, SOL…), `name`, `rank` (market cap rank) |
| **Pricing** | `price_usd` (current spot in USD) |
| **Market structure** | `market_cap_usd`, `volume_24h_usd` |
| **Supply** | `circulating_supply`, `total_supply`, `max_supply` (null for inflationary chains like ETH) |
| **Performance windows** | `change_pct_1h`, `change_pct_24h`, `change_pct_7d`, `change_pct_30d`, `change_pct_ytd` |
| **All-time-high context** | `ath`, `ath_date`, `ath_change_pct` |
| **All-time-low context** | `atl`, `atl_change_pct` |
| **Classification** | `category` (Layer1 / Layer2 / DeFi / Meme / Stablecoin / Exchange / Privacy / Gaming / AI / RWA / Smart Contract / Other), `is_stablecoin`, `is_meme` |
| **Provenance** | `data_source` (always `coingecko`) |

YTD is computed as a documented proxy: CoinGecko's 1y return × fraction-of-calendar-year-elapsed. Precise YTD across calendar boundaries requires CoinGecko Pro historical endpoints; everything else is exact.

---

### Use Cases

- **Crypto hedge funds & basket managers** — daily rebalance snapshots, sector tilts (long L1 / short Meme), ATH proximity screens, large-cap-only baskets with `min_market_cap_usd`.
- **DeFi protocols & DAOs** — collateral whitelists, oracle backstops, governance dashboards that need to flag stablecoin de-pegs or top-of-book DeFi tokens.
- **Market makers & OTC desks** — universe definition for top-of-book quoting, daily liquidity tier mapping, scrape-and-stage feed for in-house pricing engines.
- **Crypto treasury teams** — exclude-stablecoin views for directional exposure reporting; treat your USDC pile as cash and report the rest.
- **Fintech apps adding a crypto tab** — neobanks, brokerage UIs, robo-advisors building a "crypto markets" page without paying CoinMarketCap Pro per-month-per-app.
- **Quant researchers & academics** — reproducible, dated, version-controlled snapshots for back-testing factor strategies (size, momentum, mean-reversion) on the crypto universe.
- **Founders & analysts writing crypto research** — pull a clean dated snapshot for newsletters, decks, and Substack posts without manually exporting from a CoinGecko UI.

---

### Quick Start

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Full Top 100 (default)
run = client.actor("nexgendata/crypto-top100-screener").call(run_input={})

## Or a DeFi-only large-cap basket
run = client.actor("nexgendata/crypto-top100-screener").call(run_input={
    "limit": 25,
    "categories": ["DeFi"],
    "min_market_cap_usd": 500_000_000,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["symbol"], item["price_usd"], item["change_pct_7d"], item["category"])
````

#### Sample output (one record)

```json
{
  "symbol": "BTC",
  "name": "Bitcoin",
  "rank": 1,
  "price_usd": 81087,
  "market_cap_usd": 1623636576212,
  "volume_24h_usd": 31048495594,
  "circulating_supply": 20028212.0,
  "total_supply": 20028221.0,
  "max_supply": 21000000.0,
  "change_pct_1h": -0.18,
  "change_pct_24h": 0.37,
  "change_pct_7d": 0.26,
  "change_pct_30d": 13.43,
  "change_pct_ytd": -8.42,
  "ath": 126080,
  "ath_date": "2025-10-06T18:57:42.558Z",
  "ath_change_pct": -35.69,
  "atl": 67.81,
  "atl_change_pct": 119480.87,
  "category": "Layer1",
  "is_stablecoin": false,
  "is_meme": false,
  "data_source": "coingecko"
}
```

#### Input filters

| Field | Type | Default | Purpose |
|---|---|---|---|
| `limit` | int 1–250 | 100 | How many cryptos to return, ranked by market cap. |
| `exclude_stablecoins` | bool | false | Drop USDT, USDC, DAI, FDUSD, USDe, PYUSD, FRAX, etc. |
| `exclude_memes` | bool | false | Drop DOGE, SHIB, PEPE, WIF, BONK, FLOKI, TRUMP, etc. |
| `categories` | array of strings | \[] | Whitelist categories (Layer1, Layer2, DeFi, Meme, Stablecoin, Exchange, Privacy, Gaming, AI, RWA, Smart Contract, Other). |
| `min_market_cap_usd` | int | 0 | Drop coins below this market cap floor. |

When any filter is active the actor over-fetches up to 250 rows from CoinGecko so the post-filter result still fills `limit` whenever possible.

***

### Pricing

Pay-per-event, no subscription, no platform fee.

| Event | Price |
|---|---|
| Actor start | **$0.01 / run** |
| Crypto record | **$0.05 / record** |

**Daily Top 100 snapshot:** $5.01 end-to-end.
**Weekly DeFi-only basket of 25:** $1.26.
**10-asset smoke test:** $0.51.
**Monthly Top 100 (30 daily runs):** ~$150.30 — vs CoinGecko Pro Analyst at $129/mo with rate limits, or CoinMarketCap Pro Hobbyist at $333/mo.

***

### Comparison vs the obvious incumbents

| Vendor | Cost (top-100 daily) | Setup | Schema-stable JSON | Rate limits |
|---|---|---|---|---|
| **NexGenData Crypto Top 100** | **~$5.01 per run** (pay-per-result) | None — `apify call`, done | Yes, this README is the contract | None — built-in 429 retry |
| CoinGecko Pro | $129/mo Analyst (lowest paid tier) | API key + tier upgrade | Yes | 500 calls/min |
| CoinMarketCap Pro | $333/mo Hobbyist / $899/mo Startup | API key + plan selection | Yes | 30 calls/min Hobbyist |
| Messari Pro / Enterprise | ~$2,000+/mo | Sales call + procurement | Yes | Plan-tier |
| Glassnode / Kaiko | $1,000–$5,000+/mo | Sales contract | Yes (institutional tick / on-chain — more than you need here) | Plan-tier |
| CryptoCompare | $79/mo Pro / $799/mo Enterprise | API key | Partial — fields rotate | Tiered |

If you need raw tick data with order-book depth, use **Kaiko**. If you need on-chain UTXO analytics, use **Glassnode**. If you need a Bloomberg-stitched UI, pay Bloomberg. For **a clean Top 100 snapshot with category classification and zero SDK overhead**, this actor is the right tool.

***

### Sister Actors in the NexGenData Fleet

Pair the Crypto Top 100 Screener with these cross-asset trackers to build a complete institutional data spine.

| Use case | Actor |
|---|---|
| Commodity futures (gold, oil, copper, ag) — the alt-asset complement to crypto | [commodity-futures-tracker](https://apify.com/nexgendata/commodity-futures-tracker) |
| Treasury yields (UST 2y/10y/30y) — crypto correlates with real yields | [treasury-yields-bonds](https://apify.com/nexgendata/treasury-yields-bonds) |
| MCP server fronting the full NexGenData fleet for Claude / Cursor / GPT | [finance-mcp-server](https://apify.com/nexgendata/finance-mcp-server) |
| Spot BTC ETFs (IBIT, FBTC), futures-based crypto ETFs (BITO), crypto-equity ETFs | [etf-holdings-tracker](https://apify.com/nexgendata/etf-holdings-tracker) |
| Full US equity screening for crypto-adjacent equities (MSTR, COIN, MARA, RIOT, HUT, CIFR) | [finviz-stock-screener](https://apify.com/nexgendata/finviz-stock-screener) |
| FX rates (DXY, EUR/USD, JPY/USD) — risk-on/risk-off complement | [fx-rates-tracker](https://apify.com/nexgendata/fx-rates-tracker) |
| IPO calendar (US listings, lockup expiries, S-1 watch) for crypto-adjacent listings | [ipo-tracker](https://apify.com/nexgendata/ipo-tracker) |
| Eastmoney / China A-share screener for cross-region crypto-adjacent equities | [eastmoney-stock-screener](https://apify.com/nexgendata/eastmoney-stock-screener) |

Together these eight actors cover crypto, US equity micro, ETFs, commodities, rates, FX, IPO supply, and China — every cross-asset surface a multi-strategy desk touches.

***

### FAQ

**Is this legal? Is the data licensed?**
Data is sourced from CoinGecko's free public `/coins/markets` endpoint, the same one their website uses. CoinGecko brand and trademarks are property of CoinGecko Pte Ltd. This actor adds normalization, category classification, schema stability, and operational reliability — it does not redistribute proprietary CoinGecko Pro datasets.

**How fresh is the data?**
Spot prices and 24h volumes update every few minutes on CoinGecko's side. Every actor run hits the live endpoint — there is no cached layer in front. For minute-bar freshness, schedule the actor every 5–15 minutes; for daily snapshots, run once per day.

**What about rate limits?**
You hit zero rate limits as a buyer. The actor handles CoinGecko's free-tier rate limit internally with exponential backoff and retry. Even at peak market times we have not seen a run fail in production.

**Is the schema stable? Can I rely on it for production ETL?**
Yes. The 22 fields listed under "What You Get" are the contract. We absorb upstream CoinGecko field renames so your downstream Snowflake/BigQuery/DuckDB tables don't break. If we ever need a breaking change we'll publish it under a new version tag, not silently shift the existing one.

**Can I get 5-minute bars / OHLC / order book depth?**
No — this actor is purpose-built for the Top 100 snapshot use case (basket construction, daily monitoring, fintech display). For tick data and order books, use **Kaiko** or your venue's WebSocket directly. For on-chain UTXO analytics, use **Glassnode**.

**How does YTD work?**
YTD is a documented proxy: CoinGecko's 1y change × (days\_into\_year / 365). It's accurate enough for newsletters, dashboards, and dispersion analysis. For deterministic calendar-boundary YTD, we can wire in CoinGecko Pro historical endpoints on request.

**What output formats are supported?**
Apify dataset native — pull as JSON, CSV, XLSX, RSS, or HTML table. Stream directly into webhooks, Snowflake, BigQuery, or any S3-compatible store. The `apify_client` SDK works for Python, Node, and any HTTP client.

***

### About NexGenData

NexGenData publishes 200+ buyer-intent actors covering SEC filings, YC alumni, Delaware DOC, lead generation, competitive intelligence, stock fundamentals across 30+ exchanges, IPO calendars, ETF holdings, treasury yields, commodity futures, FX rates, and crypto. **All pay-per-result, no subscriptions.** Browse the full catalog at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

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

Maximum number of cryptocurrencies to return, ranked by market cap descending. Set to 100 to receive the full Top 100 universe; lower values are useful for quick smoke tests or for fintech apps that only care about majors. Range 1–250.

## `exclude_stablecoins` (type: `boolean`):

When true, filters out USD/EUR stablecoins (USDT, USDC, DAI, FDUSD, TUSD, USDe, PYUSD, etc.). Treasury teams holding stablecoins as cash typically want them excluded from a directional crypto exposure view. Default false.

## `exclude_memes` (type: `boolean`):

When true, filters out meme coins (DOGE, SHIB, PEPE, WIF, BONK, FLOKI, etc.). Institutional funds and treasury teams often want a 'serious altcoin' view that excludes meme-driven assets. Default false.

## `categories` (type: `array`):

Optional list of categories to include. Allowed values: 'Layer1', 'Layer2', 'DeFi', 'Meme', 'Stablecoin', 'Exchange', 'Smart Contract', 'Privacy', 'Gaming', 'AI', 'RWA', 'Other'. Leave empty to include all categories. Useful for DeFi protocols (filter to 'DeFi') or L2 specialists (filter to 'Layer2').

## `min_market_cap_usd` (type: `integer`):

Drop coins below this market cap threshold. Useful for hedge funds that require a minimum liquidity floor (e.g. 1\_000\_000\_000 for a 'large-cap only' screen). Set 0 to include everything.

## Actor input object example

```json
{
  "limit": 100,
  "exclude_stablecoins": false,
  "exclude_memes": false,
  "categories": [],
  "min_market_cap_usd": 0
}
```

# 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 = {
    "limit": 100,
    "exclude_stablecoins": false,
    "exclude_memes": false,
    "categories": [],
    "min_market_cap_usd": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/crypto-top100-screener").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 = {
    "limit": 100,
    "exclude_stablecoins": False,
    "exclude_memes": False,
    "categories": [],
    "min_market_cap_usd": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/crypto-top100-screener").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 '{
  "limit": 100,
  "exclude_stablecoins": false,
  "exclude_memes": false,
  "categories": [],
  "min_market_cap_usd": 0
}' |
apify call nexgendata/crypto-top100-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/crypto-top100-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🪙 Crypto Top 100 Screener — Market Cap, Volume, ATH",
        "description": "Track top 100 cryptocurrencies by market cap: Bitcoin, Ethereum, Solana, plus DeFi, Layer 2, and altcoins. Real-time prices, 24h/7d/30d/YTD performance, supply data, all-time-high tracking. CoinGecko-quality data for crypto funds, DeFi, market makers, treasury teams, fintech. Pay-per-result.",
        "version": "0.0",
        "x-build-id": "b22FxPVbAOshseZGu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~crypto-top100-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-crypto-top100-screener",
                "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/nexgendata~crypto-top100-screener/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-crypto-top100-screener",
                "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/nexgendata~crypto-top100-screener/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-crypto-top100-screener",
                "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": {
                    "limit": {
                        "title": "Limit (number of cryptos)",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of cryptocurrencies to return, ranked by market cap descending. Set to 100 to receive the full Top 100 universe; lower values are useful for quick smoke tests or for fintech apps that only care about majors. Range 1–250.",
                        "default": 100
                    },
                    "exclude_stablecoins": {
                        "title": "Exclude stablecoins",
                        "type": "boolean",
                        "description": "When true, filters out USD/EUR stablecoins (USDT, USDC, DAI, FDUSD, TUSD, USDe, PYUSD, etc.). Treasury teams holding stablecoins as cash typically want them excluded from a directional crypto exposure view. Default false.",
                        "default": false
                    },
                    "exclude_memes": {
                        "title": "Exclude meme coins",
                        "type": "boolean",
                        "description": "When true, filters out meme coins (DOGE, SHIB, PEPE, WIF, BONK, FLOKI, etc.). Institutional funds and treasury teams often want a 'serious altcoin' view that excludes meme-driven assets. Default false.",
                        "default": false
                    },
                    "categories": {
                        "title": "Categories filter",
                        "type": "array",
                        "description": "Optional list of categories to include. Allowed values: 'Layer1', 'Layer2', 'DeFi', 'Meme', 'Stablecoin', 'Exchange', 'Smart Contract', 'Privacy', 'Gaming', 'AI', 'RWA', 'Other'. Leave empty to include all categories. Useful for DeFi protocols (filter to 'DeFi') or L2 specialists (filter to 'Layer2').",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "min_market_cap_usd": {
                        "title": "Minimum market cap (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop coins below this market cap threshold. Useful for hedge funds that require a minimum liquidity floor (e.g. 1_000_000_000 for a 'large-cap only' screen). Set 0 to include everything.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
