# Formula 1 Scraper | F1 Race Results and Standings (`parseforge/formula1-scraper`) Actor

Extract Formula 1 race results, qualifying times, driver standings, constructor standings, schedules, lap data, and circuit info from Formula1.com. Build motorsport analytics, fantasy F1 tools, and historical race databases for fans, journalists, and betting models.

- **URL**: https://apify.com/parseforge/formula1-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)

## 🏎️ Formula 1 Stats Scraper

> 🚀 **Export F1 driver standings, race results, and championship data in seconds.** No login, no API key, no rate limits. Powered by the public Jolpica/Ergast F1 API.

> 🕒 **Last updated:** 2026-05-22 · **📊 24 fields** per record · **🏁 1950-present** · **🌍 Every F1 season**

Pull driver standings, constructor standings, race results, and full race schedules for any Formula 1 season from 1950 to the current year. Data is sourced in real time from the Jolpica/Ergast F1 API, the most complete and reliable open F1 data source available.

Coverage spans every race weekend from the 1950 British Grand Prix through the current season. Whether you need Max Verstappen's 2024 championship points, Lewis Hamilton's career win count, or the full 2023 race calendar, this Actor delivers it instantly in JSON, CSV, Excel, or XML.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports analysts, sports bettors, motorsport journalists, fantasy F1 managers, data scientists, history enthusiasts | F1 dashboards, race prediction models, automated stats articles, live standings apps, ML training sets, 70+ years of championship records |

---

### 📋 What the Formula 1 Stats Scraper does

- 🏆 **Driver championship standings** for any season including position, points, wins, team, and nationality.
- 🏗️ **Constructor/team standings** with championship points and wins per season.
- 🏁 **Race results** showing the winner (or any position) for every round in a season.
- 📅 **Race schedule** including circuit name, country, city, date, and start time.
- 📜 **Historical depth.** Any season from **1950 to present**, plus `current` for the live season.
- 🛑 **Free tier clean.** `maxItems` limits give free users a clean 10-item preview instantly.

> 💡 **Why it matters:** the Jolpica/Ergast API is the gold standard for open F1 data, used by teams, media, and developers worldwide. This Actor wraps it in a clean, structured dataset ready for spreadsheets, BI tools, and code.

---

### 🎬 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>dataType</code></td><td>select</td><td><code>driverStandings</code></td><td>Driver Standings, Constructor Standings, Race Results, or Schedule.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>"2024"</code></td><td>Season year (1950-2025) or <code>current</code> for the live 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: 2024 driver standings.**

```json
{
    "dataType": "driverStandings",
    "season": "2024",
    "maxItems": 20
}
````

**Example: current season race schedule.**

```json
{
    "dataType": "schedule",
    "season": "current",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** use `season: "current"` to always get the latest available data for the ongoing season. For race results, the Actor returns the top finisher per race round.

***

### 📊 Output

Each record contains up to **24 fields** depending on the `dataType`. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Description |
|---|---|---|
| 🏆 `position` | integer | Championship or finishing position |
| 👤 `driverName` | string | Full driver name |
| 🆔 `driverId` | string | Driver slug |
| 🔗 `driverUrl` | string | Wikipedia URL for the driver |
| 🏗️ `constructorName` | string | Team name (constructorStandings) |
| 🆔 `constructorId` | string | Team slug (constructorStandings) |
| 🌍 `nationality` | string | Driver or constructor nationality |
| 🏎️ `constructor` | string | Team name for driver records |
| 📊 `points` | number | Championship or race points |
| 🥇 `wins` | integer | Season win count |
| 🔢 `round` | integer | Race round number |
| 🏁 `raceName` | string | Official race name |
| 🏟️ `circuitName` | string | Circuit name |
| 🌍 `country` | string | Race country |
| 📍 `locality` | string | Race city/locality |
| 📅 `raceDate` | string | Race date (YYYY-MM-DD) |
| ⏰ `raceTime` | string | Race start time UTC |
| 🔄 `laps` | integer | Laps completed (raceResults) |
| ✅ `status` | string | Finish status (Finished, +1 Lap, Accident, etc.) |
| ⚡ `fastestLapTime` | string | Fastest lap time string |
| 📅 `season` | string | Season year |
| 🏷️ `dataType` | string | Record type identifier |
| 🕒 `scrapedAt` | string | ISO timestamp when scraped |
| ❌ `error` | string | null | Error message if failed |

#### 📦 Sample records

<details>
<summary><strong>🏆 Driver Standings (2024) - Max Verstappen</strong></summary>

```json
{
    "position": 1,
    "driverName": "Max Verstappen",
    "driverId": "max_verstappen",
    "driverUrl": "http://en.wikipedia.org/wiki/Max_Verstappen",
    "nationality": "Dutch",
    "constructor": "Red Bull",
    "points": 437,
    "wins": 9,
    "season": "2024",
    "dataType": "driverStandings",
    "scrapedAt": "2026-05-22T00:00:00.000Z",
    "error": null
}
```

</details>

<details>
<summary><strong>📅 Race Schedule (2024) - Bahrain Grand Prix</strong></summary>

```json
{
    "round": 1,
    "raceName": "Bahrain Grand Prix",
    "circuitName": "Bahrain International Circuit",
    "country": "Bahrain",
    "locality": "Sakhir",
    "raceDate": "2024-03-02",
    "raceTime": "15:00:00Z",
    "season": "2024",
    "dataType": "schedule",
    "scrapedAt": "2026-05-22T00:00:00.000Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚫 | **No auth required.** Zero setup, no API key needed. |
| 📅 | **70+ years of history.** Every season from 1950 to present. |
| 🎛️ | **Four data modes.** Standings, results, schedule, constructors. |
| ⚡ | **Instant results.** API-first, no browser rendering. |
| 🔄 | **Live season support.** `current` season always returns latest data. |
| 🌍 | **Complete coverage.** Every driver, every team, every race ever. |
| 🆓 | **Free preview.** 10 records free to validate the output. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Modes | Setup |
|---|---|---|---|---|---|
| **⭐ Formula 1 Stats Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **1950-present** | **Live per run** | 4 | ⚡ Instant |
| Manual Ergast API calls | Free | 1950-present | Real time | Custom | 🐢 Hours |
| Web-scraped F1 sites | Free | Varies | Varies | 1 | ⏳ Brittle |
| Commercial sports APIs | Subscription | Broad | Real time | Many | 🗝️ Auth gated |

Pick this Actor when you want clean, structured F1 data with no setup overhead.

***

### 🚀 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 Formula 1 Stats Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick `dataType`, enter a `season` year or `current`, and set `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 and Data Science

- Build championship prediction models on 70+ years of data
- Correlate circuit performance with championship outcomes
- Identify driver/team switching effects
- Train ML models on structured per-race records

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

#### 🎲 Sports Betting and Research

- Build betting models from race-by-race history
- Compare driver performance across circuit types
- Quantify team configuration changes
- Backtest betting strategies on historical data

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

#### 📰 Motorsport Journalism and Content

- Pull standings automatically for articles
- Generate infographics from structured data
- Skip manual stat-checking entirely
- Power weekly recap social posts

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

#### 🕹️ Fantasy F1 and Gaming

- Integrate live standings into Fantasy F1 apps
- Power scoreboards and Discord bots
- Use `current` season for always-fresh data
- Build league-tracking dashboards

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

***

### 🔌 Automating Formula 1 Stats 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 on any cron interval. Schedule a Monday-morning standings pull and keep downstream databases in sync automatically.

***

### 🌟 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 history papers on regulation changes
- Studies of nationality distribution over 70 years
- Teaching datasets for statistics courses
- Reproducible motorsport analyses

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

#### 🎨 Personal and creative

- F1 visualizations and infographics
- Generative art from standings data
- Interactive championship timelines
- Personal driver-tracking dashboards

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

#### 🤝 Non-profit and civic

- Open educational F1 history projects
- Motorsport community archives
- Junior driver development context
- Public-domain stats for fan communities

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

#### 🧪 Experimentation

- Race outcome classifiers
- Constructor dominance simulations
- LLM-powered F1 trivia bots
- Teammate head-to-head analyses

</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%20Formula%201%20Stats%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%20Formula%201%20Stats%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%20Formula%201%20Stats%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%20Formula%201%20Stats%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

#### 📜 How far back does the data go?

The Jolpica/Ergast API covers every Formula 1 season from 1950 to the present. You can retrieve standings and results for any year.

#### 🔄 Can I get live race data?

Yes. Use `season: "current"` to get the most recent available data for the ongoing season. Results are updated after each race weekend.

#### 🏁 What does `dataType: "raceResults"` return?

One record per race round showing the race winner (position 1 finisher) along with circuit details, points, laps, and finish status.

#### 📦 How many items does a free account get?

Free users get up to 10 records per run as a preview. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) for up to 1,000,000 items.

#### 🔑 Do I need an API key or credentials?

No. The Jolpica/Ergast F1 API is completely public. This Actor requires zero credentials.

#### 📥 What output formats are available?

JSON, JSONL, CSV, Excel, XML, and RSS, all available from the Apify dataset download panel.

#### 🏎️ Can I get qualifying results?

The current version focuses on race results, standings, and schedules. Qualifying data can be added in a future version.

#### ✅ What is the `status` field in raceResults?

It shows how each driver finished: "Finished" for clean finishes, "+1 Lap" for lapped cars, or reasons like "Accident", "Engine", "Gearbox" for retirements.

#### 🏟️ Can I get all finishers for each race, not just the winner?

The current Actor returns the top finisher per race for the `raceResults` mode. For full race grids, contact ParseForge for a custom configuration.

#### 🛡️ Is the data reliable?

Yes. The Jolpica/Ergast API is maintained by the motorsport data community and is the most widely used open F1 data source, powering thousands of apps and dashboards globally.

#### ⏰ Can I schedule regular runs?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run this Actor weekly or after each race weekend.

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

Formula 1 Stats 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 race 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

- [**♟️ Chess.com Scraper**](https://apify.com/parseforge/chess-com-scraper) - Chess player profiles, games, and rankings
- [**🥊 UFC Stats Scraper**](https://apify.com/parseforge/ufc-stats-scraper) - Fighter records and performance 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
- [**🏈 ESPN Standings Scraper**](https://apify.com/parseforge/espn-standings-scraper) - Live NFL, NBA, MLB, NHL, MLS standings

> 💡 **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 Formula 1, the FIA, or any team. It uses the public Jolpica/Ergast F1 API. All trademarks mentioned are the property of their respective owners. Only publicly available data is collected.

# Actor input Schema

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

Type of Formula 1 data to collect

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

Season year (e.g. 2024, 2023) or 'current' for the ongoing season

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

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

## Actor input object example

```json
{
  "dataType": "driverStandings",
  "season": "2024",
  "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/formula1-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/formula1-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/formula1-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Formula 1 Scraper | F1 Race Results and Standings",
        "description": "Extract Formula 1 race results, qualifying times, driver standings, constructor standings, schedules, lap data, and circuit info from Formula1.com. Build motorsport analytics, fantasy F1 tools, and historical race databases for fans, journalists, and betting models.",
        "version": "0.1",
        "x-build-id": "cQEpHLEVIT1GJCvHO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~formula1-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-formula1-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~formula1-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-formula1-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~formula1-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-formula1-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": {
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "driverStandings",
                            "constructorStandings",
                            "raceResults",
                            "schedule"
                        ],
                        "type": "string",
                        "description": "Type of Formula 1 data to collect",
                        "default": "driverStandings"
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Season year (e.g. 2024, 2023) or 'current' for the ongoing season",
                        "default": "2024"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
