# Speedrun.com Leaderboards Scraper (`parseforge/speedrun-leaderboards-scraper`) Actor

Pull full game leaderboards from speedrun.com by game name or category. Returns each ranked run with player, finishing time, run date, platform, region, video link, and verification date. Handy for tracking records, archiving standings, or studying run time trends.

- **URL**: https://apify.com/parseforge/speedrun-leaderboards-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏁 Speedrun.com Leaderboards Scraper

> 🚀 **Pull full-game leaderboards from speedrun.com in one run.** Give it a game name and get every top run with place, player, time, platform, region, and video link.

> 🕒 **Last updated:** 2026-06-04 · **📊 16 fields** per record · Any game on speedrun.com · Full-game categories

Speedrun.com is the central record book for the speedrunning community, tracking verified completions across thousands of games. This Actor turns any game's full-game leaderboards into a clean, structured table you can analyze, archive, or feed into your own tools.

Point it at a game by name and it resolves the game, walks every full-game category (such as 120 Star, 70 Star, Any%, or 100%), and returns the ranked runs with player names, finishing times, the platform and region a run was played on, the verification date, and the run video. Want a single category? Add a category name and it scopes to just that board.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Speedrun community organizers | Build and archive leaderboard snapshots over time |
| Esports and gaming analysts | Track records, pace progression, and platform splits |
| Content creators and streamers | Pull current top runs and video links for highlights |
| Data and hobby researchers | Study run-time distributions across categories and games |
| Tournament and event staff | Verify standings and seed brackets from live boards |

### 📋 What the Speedrun.com Leaderboards Scraper does

This Actor reads the public speedrun.com API and returns the runs that make up a game's full-game leaderboards. It:

- Resolves a game from its name automatically (first match on speedrun.com).
- Lists every full-game category for that game, or just one if you name it.
- Returns each ranked run with place, player, finishing time, date, platform, region, video link, comment, and verification date.
- Resolves player names, platforms, and regions inline so you get readable values instead of internal IDs.
- Handles guest runners and multi-runner entries.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Key | Type | Description |
|---|---|---|---|
| 🎮 Game Name | `gameName` | string | Game to look up on speedrun.com. Required. The first matching game is resolved automatically. |
| 🏷 Category Name | `categoryName` | string | Optional. Limit results to one full-game category by name, such as `70 Star` or `Any%`. Leave empty to scrape every full-game category. |
| 🔢 Top N Runs | `topN` | integer | How many top runs to pull from each leaderboard. Default 50. |
| 📦 Max Items | `maxItems` | integer | Cap on total runs returned. Free plan is limited to 10. |

**Example 1 — every full-game category of a game:**

```json
{
    "gameName": "Super Mario 64",
    "topN": 50,
    "maxItems": 200
}
````

**Example 2 — a single category, top 10 runs:**

```json
{
    "gameName": "Super Mario 64",
    "categoryName": "70 Star",
    "topN": 10,
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** The game name resolves to the closest match on speedrun.com, so use the title as it appears on the site. Category names are matched exactly, so `Any%` and `70 Star` must be spelled as shown on the game's page. The public speedrun.com API can be slow and rate-limits heavy use, so very large pulls take longer.

### 📊 Output

Each record is one ranked run on a leaderboard.

| Field | Key | Description |
|---|---|---|
| 🎮 Game | `game` | Game title |
| 🏷 Category | `category` | Full-game category name |
| 🥇 Place | `place` | Rank on the leaderboard |
| 🏃 Player | `playerName` | Runner name (or names for co-op runs) |
| ⏱ Time | `runTime` | Finishing time as an ISO 8601 duration |
| ⏲ Time (s) | `runTimeSeconds` | Finishing time in seconds |
| 📅 Date | `date` | Date the run was performed |
| 🕹 Platform | `platform` | Console or platform used |
| 🌍 Region | `region` | Hardware region |
| 🎛 Emulated | `emulated` | Whether the run used an emulator |
| 🎬 Video | `videoLink` | Link to the run video |
| 💬 Comment | `comment` | Runner comment |
| ✅ Verified | `verifiedDate` | When a moderator verified the run |
| 🆔 Run ID | `runId` | speedrun.com run identifier |
| 🔗 Web Link | `weblink` | Public page for the run |
| 🕒 Scraped | `scrapedAt` | When this record was collected |

**Real sample records:**

```json
{
    "game": "Super Mario 64",
    "category": "120 Star",
    "place": 1,
    "playerName": "Suigi",
    "runTime": "PT1H35M14S",
    "runTimeSeconds": 5714,
    "date": "2026-04-26",
    "platform": "Nintendo 64",
    "region": "JPN / NTSC",
    "emulated": false,
    "videoLink": "https://www.youtube.com/watch?v=KboxS9NNFJMhttps://youtu.be/KboxS9NNFJM",
    "comment": "https://www.youtube.com/watch?v=KboxS9NNFJMhttps://youtu.be/KboxS9NNFJM\n\nsolid",
    "verifiedDate": "2026-04-30T02:48:05Z",
    "runId": "z5npldjz",
    "weblink": "https://www.speedrun.com/sm64/runs/z5npldjz",
    "scrapedAt": "2026-06-04T19:28:31.034Z"
}
```

```json
{
    "game": "Super Mario 64",
    "category": "120 Star",
    "place": 2,
    "playerName": "Karin",
    "runTime": "PT1H35M30S",
    "runTimeSeconds": 5730,
    "date": "2025-08-11",
    "platform": "Nintendo 64",
    "region": "JPN / NTSC",
    "emulated": false,
    "videoLink": "https://www.youtube.com/watch?v=sjKi6aruFVs?t=1",
    "comment": "https://www.youtube.com/watch?v=sjKi6aruFVs?t=1",
    "verifiedDate": "2025-08-16T01:58:59Z",
    "runId": "yv77ke4y",
    "weblink": "https://www.speedrun.com/sm64/runs/yv77ke4y",
    "scrapedAt": "2026-06-04T19:28:31.114Z"
}
```

```json
{
    "game": "Super Mario 64",
    "category": "120 Star",
    "place": 2,
    "playerName": "anonymous",
    "runTime": "PT1H35M30S",
    "runTimeSeconds": 5730,
    "date": "2025-03-19",
    "platform": "Nintendo 64",
    "region": "JPN / NTSC",
    "emulated": false,
    "videoLink": null,
    "comment": "Mod note: This runner has chosen to remove their run from the leaderboard but it has been verified and backed up.",
    "verifiedDate": "2025-09-16T15:59:21Z",
    "runId": "z00v01jz",
    "weblink": "https://www.speedrun.com/sm64/runs/z00v01jz",
    "scrapedAt": "2026-06-04T19:28:31.136Z"
}
```

### ✨ Why choose this Actor

- **Readable values, not IDs.** Player names, platforms, and regions are resolved for you.
- **One game name in, full boards out.** No need to dig up internal game or category identifiers.
- **Category control.** Scrape every full-game category or scope to exactly one.
- **Verification aware.** Each run carries its moderator verification date.
- **Handles edge cases.** Guest runners and co-op entries come through cleanly.

### 📈 How it compares to alternatives

| Approach | Setup effort | Readable platform and region | Multi-category in one run | Maintenance |
|---|---|---|---|---|
| This Actor | Type a game name | Yes | Yes | Managed |
| Hand-querying the public API | Learn endpoints and embeds | Manual ID lookups | Build it yourself | Yours to keep |
| Copying from the website | None | Yes, but manual | Tedious | Constant |

### 🚀 How to use

1. **Create a free Apify account** using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Speedrun.com Leaderboards Scraper in the Apify Console.
3. Enter a **game name** (try `Super Mario 64`), and optionally a **category name** and **Top N**.
4. Click **Start** and watch the runs populate.
5. Download your results or connect them to the integrations below.

### 💼 Business use cases

**Community and events**

| Goal | How this helps |
|---|---|
| Archive leaderboards | Snapshot boards on a schedule for history |
| Seed tournaments | Pull current standings to build brackets |

**Analytics**

| Goal | How this helps |
|---|---|
| Track record pace | Compare finishing times across dates |
| Platform splits | Group runs by platform and region |

**Content**

| Goal | How this helps |
|---|---|
| Highlight reels | Grab top runs with their video links |
| Social posts | Surface new records the moment they verify |

**Research**

| Goal | How this helps |
|---|---|
| Run-time distributions | Study how times cluster per category |
| Cross-game comparisons | Pull several games into one table |

### 🔌 Automating Speedrun.com Leaderboards Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** for no-code workflows.
- **Slack** to post new top runs to a channel.
- **Airbyte** to sync runs into a warehouse.
- **GitHub** Actions to run on a schedule.
- **Google Drive** to archive snapshots.

### 🌟 Beyond business use cases

- **Research:** analyze how speedrun times evolve over a game's life.
- **Personal:** keep a private record of your favorite category's top 10.
- **Non-profit:** support charity speedrun events with live standings.
- **Experimentation:** build a small dashboard of records you care about.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask questions like "Which platform dominates this leaderboard?" or "Summarize how the record improved over the last year."

### ❓ Frequently Asked Questions

**Does this need an API key?**
No. It uses the public speedrun.com API, no key or login required.

**How do I find the right game name?**
Use the title as it appears on speedrun.com. The first matching game is selected.

**What is a full-game category?**
A leaderboard for completing the whole game under a ruleset, such as 120 Star or Any%. Individual-level boards are not included.

**Can I scrape just one category?**
Yes. Set `categoryName` to the exact category name shown on the game's page.

**Are individual-level (IL) runs included?**
No. This Actor focuses on full-game leaderboards.

**Why is a video link sometimes empty?**
Not every run has a public video attached, so that field can be empty for some runs.

**What do the times mean?**
`runTime` is an ISO 8601 duration and `runTimeSeconds` is the same value in seconds for easy sorting.

**Are guest runners supported?**
Yes. Runs by guests appear with their guest name.

**How many runs can I pull?**
Set `topN` per leaderboard and `maxItems` for the total. Free accounts are capped at 10 items.

**Is the data verified?**
Each run includes the moderator verification date from speedrun.com.

**Why is the run sometimes slow?**
The public speedrun.com API rate-limits heavy use, so very large pulls take longer.

**Is this affiliated with speedrun.com?**
No. It is an independent tool that reads only publicly available data.

### 🔌 Integrate with any app

Results live in a standard Apify dataset, so you can connect them to webhooks, the Apify API, or any of the integrations listed above.

### 🔗 Recommended Actors

- [Steam Store Scraper](https://apify.com/parseforge/steam-store-scraper) — game listings, prices, and details from the Steam store.
- [Understat xG Scraper](https://apify.com/parseforge/understat-xg-scraper) — expected-goals football stats for matches and players.
- [Rebrickable LEGO Scraper](https://apify.com/parseforge/rebrickable-lego-scraper) — LEGO sets, parts, and minifigures data.
- [OpenChargeMap Scraper](https://apify.com/parseforge/openchargemap-scraper) — EV charging station locations and details.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with speedrun.com. Only publicly available data collected.

# Actor input Schema

## `gameName` (type: `string`):

Name of the game to look up on speedrun.com (for example Super Mario 64). The first matching game is resolved automatically.

## `categoryName` (type: `string`):

Limit results to one full-game category by name (for example 70 Star, Any%). Leave empty to scrape every full-game category of the game.

## `topN` (type: `integer`):

How many top runs to pull from each leaderboard.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "gameName": "Super Mario 64",
  "categoryName": "70 Star",
  "topN": 50,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "gameName": "Super Mario 64",
    "categoryName": "70 Star",
    "topN": 50,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/speedrun-leaderboards-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 = {
    "gameName": "Super Mario 64",
    "categoryName": "70 Star",
    "topN": 50,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/speedrun-leaderboards-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 '{
  "gameName": "Super Mario 64",
  "categoryName": "70 Star",
  "topN": 50,
  "maxItems": 10
}' |
apify call parseforge/speedrun-leaderboards-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Speedrun.com Leaderboards Scraper",
        "description": "Pull full game leaderboards from speedrun.com by game name or category. Returns each ranked run with player, finishing time, run date, platform, region, video link, and verification date. Handy for tracking records, archiving standings, or studying run time trends.",
        "version": "0.1",
        "x-build-id": "o8m1UJM8KJAnUqaC7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~speedrun-leaderboards-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-speedrun-leaderboards-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/parseforge~speedrun-leaderboards-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-speedrun-leaderboards-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/parseforge~speedrun-leaderboards-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-speedrun-leaderboards-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",
                "required": [
                    "gameName"
                ],
                "properties": {
                    "gameName": {
                        "title": "Game Name",
                        "type": "string",
                        "description": "Name of the game to look up on speedrun.com (for example Super Mario 64). The first matching game is resolved automatically."
                    },
                    "categoryName": {
                        "title": "Category Name (optional)",
                        "type": "string",
                        "description": "Limit results to one full-game category by name (for example 70 Star, Any%). Leave empty to scrape every full-game category of the game."
                    },
                    "topN": {
                        "title": "Top N Runs Per Leaderboard",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many top runs to pull from each leaderboard."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
