# ESPN Standings Scraper | League Tables and Records (`parseforge/espn-standings-scraper`) Actor

Extract league standings from ESPN for NFL, NBA, MLB, NHL, MLS, and college sports including wins, losses, ties, points, win percentage, streaks, and division rankings. Power sports apps, fantasy tools, team performance dashboards, and historical records research.

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

## Pricing

from $19.00 / 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)

## 🏆 ESPN Standings & Scoreboard Scraper

> 🚀 **Export live NFL, NBA, MLB, NHL, and MLS standings and scores from ESPN in seconds.** No API key required. Just pick a league and download.

> 🕒 **Last updated:** 2026-05-22 · **📊 16 fields** per record · **🏟️ 153+ teams** · **🥇 5 major leagues**

Pull real-time standings tables and scoreboard data directly from ESPN's public API. Whether you need win-loss records, winning percentages, point differentials, or current streaks, this Actor delivers clean structured data for every team in the league.

Data comes straight from ESPN's internal API, the same source powering ESPN.com, so you always get the most current standings without scraping HTML. Coverage spans 5 major North American sports leagues: NFL (32 teams), NBA (30 teams), MLB (30 teams), NHL (32 teams), and MLS (29+ teams).

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports analysts, fantasy managers, sports journalists, betting researchers, app developers, data scientists | Standings dashboards, fantasy team monitoring, automated articles, predictive modeling, sports apps, team performance analysis |

---

### 📋 What the ESPN Standings Scraper does

- 🏈 **Five major leagues.** NFL, NBA, MLB, NHL, MLS, all in one Actor.
- 📊 **Standings mode.** Wins, losses, ties, win pct, games back, points for/against, streak.
- 🆚 **Scoreboard mode.** Real-time game scores, status, home/away teams, venue.
- 📅 **Historical seasons.** Query any past season by year (e.g. 2020, 2021, 2022, 2023, 2024).
- ⚡ **Under 10 seconds.** Pure API, no browser, no HTML parsing.
- 🛑 **Clean free tier.** 10-record preview for free users.

> 💡 **Why it matters:** ESPN's standings data is the industry standard reference for North American sports. Instead of manually copying tables or scraping fragile HTML, this Actor gives you clean JSON you can feed directly into spreadsheets, databases, or dashboards.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>sport</code></td><td>select</td><td><code>"NBA"</code></td><td>League. NFL, NBA, MLB, NHL, or MLS.</td></tr>
<tr><td><code>dataType</code></td><td>select</td><td><code>"standings"</code></td><td>Either <code>standings</code> or <code>scoreboard</code>.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>""</code></td><td>Season year (e.g. <code>2024</code>). Empty means current season.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: NBA standings, current season.**

```json
{
    "sport": "NBA",
    "dataType": "standings",
    "maxItems": 30
}
````

**Example: NFL 2023 standings.**

```json
{
    "sport": "NFL",
    "dataType": "standings",
    "season": "2023",
    "maxItems": 32
}
```

> ⚠️ **Good to Know:** free users are limited to 10 items per run. Upgrade to a paid plan to unlock all teams and unlimited historical seasons.

***

### 📊 Output

Each standings record contains **16 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Description |
|---|---|---|
| 🏀 `teamName` | string | Full team display name |
| 🔤 `abbreviation` | string | Team abbreviation (e.g. "CLE") |
| ✅ `wins` | integer | Total wins |
| ❌ `losses` | integer | Total losses |
| 🤝 `ties` | integer | null | Total ties (null for NBA/MLB) |
| 📊 `winPct` | float | Win percentage (e.g. 0.732) |
| 📏 `gamesBack` | float | Games behind division leader |
| 🏹 `pointsFor` | float | Total points/goals scored |
| 🛡️ `pointsAgainst` | float | Total points/goals allowed |
| 🔥 `streak` | string | Current streak (e.g. "W3", "L2") |
| 🌐 `conference` | string | Conference name |
| 🗂️ `division` | string | null | Division name (null if not applicable) |
| 🏆 `sport` | string | League identifier |
| 📅 `season` | string | Season year or "current" |
| 🕒 `scrapedAt` | string | ISO timestamp of scrape |
| ❌ `error` | string | null | Error message if applicable |

#### 📦 Sample record

<details>
<summary><strong>🏀 NBA standings: Cleveland Cavaliers</strong></summary>

```json
{
    "teamName": "Cleveland Cavaliers",
    "abbreviation": "CLE",
    "wins": 64,
    "losses": 18,
    "ties": null,
    "winPct": 0.780,
    "gamesBack": 0,
    "pointsFor": 9847,
    "pointsAgainst": 8901,
    "streak": "W5",
    "conference": "Eastern Conference",
    "division": null,
    "sport": "NBA",
    "season": "current",
    "scrapedAt": "2026-05-22T10:00:00.000Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚀 | **Instant results.** Pure API, runs in under 10 seconds. |
| 🌐 | **Five leagues.** NFL, NBA, MLB, NHL, MLS in one Actor. |
| 📅 | **Historical seasons.** Query any past season by year. |
| 🚫 | **No auth required.** Uses ESPN's public API. |
| 🧱 | **Clean structured data.** All fields typed and normalized. |
| 🔄 | **Always current.** Same data source as ESPN.com itself. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup | Maintenance |
|---|---|---|---|---|---|
| **⭐ ESPN Standings Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **5 leagues, all teams** | **Live per run** | ⚡ 2 min | None |
| Manual ESPN copy-paste | Free | All | Manual | 🐢 10+ min | None |
| Custom HTML scraper | Free | Varies | Real time | ⏳ Hours | High, layout changes |
| Commercial sports APIs | Subscription | Broad | Real time | 🗝️ Auth gated | Vendor managed |

Pick this Actor when you want zero-setup ESPN standings without maintaining a brittle HTML scraper.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the ESPN Standings Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a `sport`, `dataType`, optional `season`, and `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Sports Analytics Platforms

- Auto-refreshing standings dashboards
- Conference and division ranking views
- Win-pct trend tracking across seasons
- Streak and momentum indicators

</td>
<td width="50%" valign="top">

#### 🎮 Fantasy Sports Tools

- Cross-league team performance monitoring
- Streak-based draft and trade insights
- Schedule strength factoring
- Notification systems on streak changes

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Sports Media and Journalism

- Automated weekly standings articles
- Newsletter-ready standings snapshots
- CMS integrations for live tables
- Auto-generated stat infographics

</td>
<td width="50%" valign="top">

#### 🎲 Betting Research and Modeling

- Build historical standings datasets
- Correlate standings with game outcomes
- Loop seasons 2018-2024 for ML training
- Backtest sport-specific predictors

</td>
</tr>
</table>

***

### 🔌 Automating ESPN Standings Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor daily, weekly, or on game-day cadences to keep dashboards and databases in sync.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Sports economics studies on win-loss patterns
- Comparative league competitive-balance research
- Teaching datasets for intro statistics
- Reproducible standings archives by year

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal sports dashboards
- Data-driven sports art and infographics
- Discord bots for fan communities
- League-tracker side projects

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Youth-league benchmarking against pro structures
- Open-data sports civic projects
- Community sports archives
- Educational sports-analytics workshops

</td>
<td width="50%">

#### 🧪 Experimentation

- Train standings-based prediction models
- Build LLM-powered sports explainers
- Prototype game-result classifiers
- Multi-season simulation environments

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20ESPN%20Standings%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20ESPN%20Standings%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20ESPN%20Standings%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20ESPN%20Standings%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🔑 Does this require an ESPN API key?

No. ESPN's standings and scoreboard endpoints are publicly accessible. No API key, no account needed.

#### 🔄 How current is the data?

Data is fetched in real time from ESPN's API on every run. Same data powering ESPN.com.

#### 📅 Can I get historical standings?

Yes. Enter a season year (e.g. "2023", "2022") in the Season Year field to get historical standings.

#### 🏈 Which leagues are supported?

NFL, NBA, MLB, NHL, and MLS. More leagues (college football, WNBA) may be added in future versions.

#### 🏟️ How many teams per league?

NFL: 32 teams, NBA: 30 teams, MLB: 30 teams, NHL: 32 teams, MLS: 29+ teams.

#### 🆚 What does "scoreboard" mode return?

Today's games with scores, game status, home/away teams, and venue information.

#### ⏰ Can I run this on a schedule?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run daily or weekly and save standings to a persistent dataset.

#### 📥 What format is the output?

JSON by default. Download as CSV, Excel, XML, or JSON from the Apify console.

#### 📦 Are free users limited?

Free users receive a 10-item preview. Paid plans unlock the full dataset (30-32 teams per league).

#### 🌐 Can I filter by conference or division?

Not currently. All conferences are returned. Filter locally by the `conference` field in the output.

#### 🏫 Does it support college sports?

Not in this version. The Actor targets the 5 major professional North American leagues.

#### 🆘 What if I need help?

Our support team is here to help. Use the Tally form linked below to reach out.

***

### 🔌 Integrate with any app

ESPN Standings Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe standings data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🏎️ Formula 1 Stats Scraper**](https://apify.com/parseforge/formula1-scraper) - F1 standings, race results, and schedules
- [**🥊 UFC Stats Scraper**](https://apify.com/parseforge/ufc-stats-scraper) - UFC fighter records and metrics
- [**⚾ Baseball Reference Scraper**](https://apify.com/parseforge/baseball-reference-scraper) - MLB historical stats
- [**🏀 Basketball Reference Scraper**](https://apify.com/parseforge/basketball-reference-scraper) - NBA player and team stats
- [**♟️ Chess.com Scraper**](https://apify.com/parseforge/chess-com-scraper) - Chess profiles and ratings

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more sports and reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by ESPN, The Walt Disney Company, or any sports league mentioned. All trademarks are the property of their respective owners. Only publicly available data from ESPN's public API endpoints is collected.

# Actor input Schema

## `sport` (type: `string`):

Which sports league to scrape

## `dataType` (type: `string`):

Standings (season standings table) or Scoreboard (today's games/scores)

## `season` (type: `string`):

Season year (e.g. '2024'). Leave empty for current season.

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

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

## Actor input object example

```json
{
  "sport": "NBA",
  "dataType": "standings",
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/espn-standings-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/espn-standings-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 '{
  "maxItems": 10
}' |
apify call parseforge/espn-standings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ESPN Standings Scraper | League Tables and Records",
        "description": "Extract league standings from ESPN for NFL, NBA, MLB, NHL, MLS, and college sports including wins, losses, ties, points, win percentage, streaks, and division rankings. Power sports apps, fantasy tools, team performance dashboards, and historical records research.",
        "version": "0.1",
        "x-build-id": "MIUlOVqiIy2hAV3Oa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~espn-standings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-espn-standings-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~espn-standings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-espn-standings-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~espn-standings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-espn-standings-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": {
                    "sport": {
                        "title": "Sport / League",
                        "enum": [
                            "NFL",
                            "NBA",
                            "MLB",
                            "NHL",
                            "MLS"
                        ],
                        "type": "string",
                        "description": "Which sports league to scrape",
                        "default": "NBA"
                    },
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "standings",
                            "scoreboard"
                        ],
                        "type": "string",
                        "description": "Standings (season standings table) or Scoreboard (today's games/scores)",
                        "default": "standings"
                    },
                    "season": {
                        "title": "Season Year",
                        "type": "string",
                        "description": "Season year (e.g. '2024'). Leave empty for current season."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
