# Polymarket Leaderboard Scraper (`automation-lab/polymarket-leaderboard-scraper`) Actor

Extract Polymarket top trader rankings by profit or volume with wallets, profiles, categories, time ranges, and source URLs.

- **URL**: https://apify.com/automation-lab/polymarket-leaderboard-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Polymarket Leaderboard Scraper

Extract top Polymarket traders from the public leaderboard with rank, profit, volume, wallet, profile, X/Twitter, category, and time-window metadata.

### What does Polymarket Leaderboard Scraper do?

Polymarket Leaderboard Scraper collects public trader leaderboard rows from Polymarket.
It uses Polymarket's public data API, so it is fast, lightweight, and does not need a login.
You can scrape the overall leaderboard or focus on categories such as crypto, sports, politics, finance, economics, tech, weather, culture, mentions, and esports.
You can rank traders by profit or by volume.
You can run one leaderboard URL or many category/time-range/rank combinations in the same Actor run.

### Who is it for?

Prediction-market traders use it to monitor the accounts currently winning on Polymarket.
Crypto analysts use it to connect Polymarket profiles with proxy wallet addresses.
Wallet intelligence teams use it to build recurring watchlists of high-volume or high-PnL traders.
Market researchers use it to compare category-level performance across politics, sports, crypto, finance, and more.
Data teams use it to feed dashboards, spreadsheets, alerts, and enrichment pipelines.

### Why use this scraper?

✅ It returns typed rows instead of screenshots or unstructured HTML.
✅ It supports profit and volume rankings.
✅ It supports Polymarket's public category and time-range filters.
✅ It includes source URLs so every row is traceable.
✅ It can save hundreds of leaderboard rows in a small HTTP-only run.
✅ It does not require cookies, private accounts, browser automation, or residential proxies.

### What data can you extract?

Each dataset item represents one Polymarket leaderboard trader row.

| Field | Description |
| --- | --- |
| `rank` | Numeric leaderboard rank. |
| `rankType` | `profit` or `volume`. |
| `timeRange` | `today`, `weekly`, `monthly`, or `all`. |
| `category` | Polymarket category such as `overall`, `crypto`, or `sports`. |
| `username` | Public Polymarket username. |
| `profileUrl` | Polymarket profile URL based on the proxy wallet. |
| `proxyWallet` | Public proxy wallet address exposed by Polymarket. |
| `walletExplorerUrl` | PolygonScan URL for the proxy wallet. |
| `xUsername` | X/Twitter username when Polymarket exposes it. |
| `xProfileUrl` | X/Twitter profile URL when available. |
| `verifiedBadge` | Whether the profile has a verified badge. |
| `profitUsd` | Public PnL/profit value in USD. |
| `volumeUsd` | Public trading volume value in USD. |
| `profileImageUrl` | Avatar/profile image URL when available. |
| `sourceLeaderboardUrl` | Human leaderboard URL for the filter. |
| `sourceApiUrl` | API URL used for the row page. |
| `scrapedAt` | ISO timestamp of extraction. |

### How much does it cost to scrape Polymarket leaderboard traders?

This Actor uses pay-per-event pricing.
There is a $0.005 start charge per run and a tiered per-trader charge for each saved leaderboard row.

| Plan tier | Per saved trader |
| --- | --- |
| Free | $0.000031846 |
| Bronze | $0.000027692 |
| Silver | $0.0000216 |
| Gold | $0.000016615 |
| Platinum | $0.000011077 |
| Diamond | $0.00001 |

For example, a default 100-row Bronze run is about $0.00777 before any Apify plan-specific display rounding.

### Input options

You can use either URL mode or selector mode.

#### URL mode

Paste Polymarket leaderboard URLs such as:

```json
{
  "startUrls": [
    { "url": "https://polymarket.com/leaderboard/overall/monthly/profit" },
    { "url": "https://polymarket.com/leaderboard/crypto/weekly/volume" }
  ],
  "maxItemsPerCombination": 100
}
````

#### Selector mode

Choose categories, time ranges, and rank types:

```json
{
  "categories": ["overall", "crypto", "sports"],
  "timeRanges": ["weekly", "monthly"],
  "rankTypes": ["profit", "volume"],
  "maxItemsPerCombination": 100
}
```

### Supported categories

- `overall`
- `politics`
- `sports`
- `esports`
- `crypto`
- `finance`
- `culture`
- `mentions`
- `weather`
- `economics`
- `tech`

### Supported time ranges

- `today`
- `weekly`
- `monthly`
- `all`

### Supported rank types

- `profit` — top traders by PnL/profit.
- `volume` — top traders by trading volume.

### Output example

```json
{
  "rank": 1,
  "rankType": "profit",
  "timeRange": "monthly",
  "category": "overall",
  "username": "swisstony",
  "profileUrl": "https://polymarket.com/profile/0x204f72f35326db932158cba6adff0b9a1da95e14",
  "proxyWallet": "0x204f72f35326db932158cba6adff0b9a1da95e14",
  "walletExplorerUrl": "https://polygonscan.com/address/0x204f72f35326db932158cba6adff0b9a1da95e14",
  "xUsername": null,
  "xProfileUrl": null,
  "verifiedBadge": false,
  "profitUsd": 3119559.0719809025,
  "volumeUsd": 230731144.9539759,
  "profileImageUrl": null,
  "sourceLeaderboardUrl": "https://polymarket.com/leaderboard/overall/monthly/profit",
  "sourceApiUrl": "https://data-api.polymarket.com/v1/leaderboard?timePeriod=month&orderBy=PNL&limit=50&offset=0&category=overall",
  "scrapedAt": "2026-07-10T06:51:24.503Z"
}
```

### How to run it on Apify

1. Open the Actor on Apify.
2. Choose URL mode or selector mode.
3. Keep `maxItemsPerCombination` small for a quick first run.
4. Click **Start**.
5. Download results as JSON, CSV, Excel, XML, RSS, or HTML table.

### Tips for better results

Start with `overall` + `monthly` + `profit` if you want a broad snapshot.
Use `all` + `volume` to find historically active wallets.
Use `crypto` or `sports` categories for category-specific trading intelligence.
Use multiple categories in one run when you want a dashboard-ready dataset.
Increase `maxItemsPerCombination` only when you need deeper ranks.

### Integrations

Send results to Google Sheets for analyst review.
Push wallet addresses into a Polygon wallet enrichment pipeline.
Join the output with market, trade, or event datasets from related Polymarket workflows.
Trigger a webhook when a known wallet enters a top rank.
Store daily snapshots in a database to track leaderboard movements over time.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/polymarket-leaderboard-scraper').call({
  categories: ['overall'],
  timeRanges: ['monthly'],
  rankTypes: ['profit'],
  maxItemsPerCombination: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/polymarket-leaderboard-scraper').call(run_input={
    'categories': ['overall'],
    'timeRanges': ['monthly'],
    'rankTypes': ['profit'],
    'maxItemsPerCombination': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~polymarket-leaderboard-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"categories":["overall"],"timeRanges":["monthly"],"rankTypes":["profit"],"maxItemsPerCombination":100}'
```

### MCP integration

Use the Apify MCP server with Claude Desktop or Claude Code to run this Actor from natural language.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/polymarket-leaderboard-scraper
```

Claude Code setup:

```bash
claude mcp add apify-polymarket-leaderboard "https://mcp.apify.com/?tools=automation-lab/polymarket-leaderboard-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-polymarket-leaderboard": {
      "url": "https://mcp.apify.com/?tools=automation-lab/polymarket-leaderboard-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the monthly Polymarket profit leaderboard and summarize the top wallets."
- "Get the top 100 crypto-category Polymarket traders by weekly volume."
- "Compare today's profit leaderboard with all-time volume leaders."

### Related scrapers

- [Polymarket Markets Scraper](https://apify.com/automation-lab/polymarket-markets-scraper) for market/event data.
- [Crypto wallet and blockchain actors](https://apify.com/automation-lab) for wallet enrichment workflows.
- [Prediction market and finance scrapers](https://apify.com/automation-lab) for broader market intelligence.

### Legality and responsible use

This Actor extracts public leaderboard data from Polymarket.
It does not bypass login-only content.
It does not place trades.
It does not access private user accounts.
You are responsible for using the output in accordance with applicable laws, platform terms, and privacy obligations.

### Troubleshooting

If a run returns fewer rows than requested, Polymarket may not expose more rows for that filter.
Try a broader category such as `overall` or a broader time range such as `all`.

If a pasted URL is ignored, make sure it contains `/leaderboard/` and follows the Polymarket pattern `/leaderboard/{category}/{timeRange}/{rankType}`.

If you need historical rank changes, schedule this Actor daily and compare snapshots by `proxyWallet`, `category`, `timeRange`, and `rankType`.

### FAQ

#### Do I need a Polymarket account?

No. The Actor reads public leaderboard data.

#### Can I scrape both profit and volume in one run?

Yes. Set `rankTypes` to `["profit", "volume"]`.

#### Can I scrape several categories at once?

Yes. Add multiple values to `categories`.

#### Does it expose wallet addresses?

It returns the public proxy wallet address when Polymarket exposes it on the leaderboard API.

#### Is this a trading bot?

No. It only extracts public leaderboard data.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

### Support

Open an issue on the Actor page if the Polymarket leaderboard changes or if you need an additional output field.

# Actor input Schema

## `startUrls` (type: `array`):

Optional Polymarket leaderboard URLs like https://polymarket.com/leaderboard/overall/monthly/profit. If provided, URL combinations override the selectors below.

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

Polymarket leaderboard categories to scrape.

## `timeRanges` (type: `array`):

Time windows for rankings.

## `rankTypes` (type: `array`):

Scrape profit leaderboards, volume leaderboards, or both.

## `maxItemsPerCombination` (type: `integer`):

Maximum leaderboard rows to save for each category/time range/rank type combination.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://polymarket.com/leaderboard/overall/monthly/profit"
    }
  ],
  "categories": [
    "overall"
  ],
  "timeRanges": [
    "monthly"
  ],
  "rankTypes": [
    "profit"
  ],
  "maxItemsPerCombination": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://polymarket.com/leaderboard/overall/monthly/profit"
        }
    ],
    "categories": [
        "overall"
    ],
    "timeRanges": [
        "monthly"
    ],
    "rankTypes": [
        "profit"
    ],
    "maxItemsPerCombination": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/polymarket-leaderboard-scraper").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 = {
    "startUrls": [{ "url": "https://polymarket.com/leaderboard/overall/monthly/profit" }],
    "categories": ["overall"],
    "timeRanges": ["monthly"],
    "rankTypes": ["profit"],
    "maxItemsPerCombination": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/polymarket-leaderboard-scraper").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 '{
  "startUrls": [
    {
      "url": "https://polymarket.com/leaderboard/overall/monthly/profit"
    }
  ],
  "categories": [
    "overall"
  ],
  "timeRanges": [
    "monthly"
  ],
  "rankTypes": [
    "profit"
  ],
  "maxItemsPerCombination": 20
}' |
apify call automation-lab/polymarket-leaderboard-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/polymarket-leaderboard-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket Leaderboard Scraper",
        "description": "Extract Polymarket top trader rankings by profit or volume with wallets, profiles, categories, time ranges, and source URLs.",
        "version": "0.1",
        "x-build-id": "xEx1hf3Bq0Mv88PRF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~polymarket-leaderboard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-polymarket-leaderboard-scraper",
                "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/automation-lab~polymarket-leaderboard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-polymarket-leaderboard-scraper",
                "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/automation-lab~polymarket-leaderboard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-polymarket-leaderboard-scraper",
                "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": {
                    "startUrls": {
                        "title": "Polymarket leaderboard URLs",
                        "type": "array",
                        "description": "Optional Polymarket leaderboard URLs like https://polymarket.com/leaderboard/overall/monthly/profit. If provided, URL combinations override the selectors below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Polymarket leaderboard categories to scrape.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "overall",
                                "politics",
                                "sports",
                                "esports",
                                "crypto",
                                "finance",
                                "culture",
                                "mentions",
                                "weather",
                                "economics",
                                "tech"
                            ],
                            "enumTitles": [
                                "All categories",
                                "Politics",
                                "Sports",
                                "Esports",
                                "Crypto",
                                "Finance",
                                "Culture",
                                "Mentions",
                                "Weather",
                                "Economics",
                                "Tech"
                            ]
                        },
                        "default": [
                            "overall"
                        ]
                    },
                    "timeRanges": {
                        "title": "Time ranges",
                        "type": "array",
                        "description": "Time windows for rankings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "today",
                                "weekly",
                                "monthly",
                                "all"
                            ],
                            "enumTitles": [
                                "Today",
                                "Weekly",
                                "Monthly",
                                "All time"
                            ]
                        },
                        "default": [
                            "monthly"
                        ]
                    },
                    "rankTypes": {
                        "title": "Rank by",
                        "type": "array",
                        "description": "Scrape profit leaderboards, volume leaderboards, or both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "profit",
                                "volume"
                            ],
                            "enumTitles": [
                                "Profit",
                                "Volume"
                            ]
                        },
                        "default": [
                            "profit"
                        ]
                    },
                    "maxItemsPerCombination": {
                        "title": "Maximum traders per combination",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum leaderboard rows to save for each category/time range/rank type combination.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```