# F1 Race Results and Standings Scraper (`parseforge/f1-ergast-results-scraper`) Actor

Pull Formula 1 race results, qualifying, sprint, drivers, constructors, circuits and championship standings from 1950 to present. Returns positions, points, lap times, fastest laps, grid positions and full driver/team metadata per race. Filter by season, round, driver, constructor or circuit.

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

## Pricing

from $12.00 / 1,000 result items

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)

## 🏎️ F1 Race Results and Standings Scraper

> 🚀 **Pull Formula 1 race results, qualifying, drivers, constructors, and championship standings from 1950 to present.**

> 🕒 **Last updated:** 2026-05-06 · **📊 34 fields** per record · **1950 to present** · races, qualifying, sprint, drivers, constructors, circuits, standings · 76+ years of F1 history

The **F1 Race Results and Standings Scraper** pulls Formula 1 data from 1950 to present. Output includes per-race results with positions, points, lap times, fastest laps, grid positions, status, plus full driver/team metadata; qualifying and sprint results; driver and constructor profiles; circuit data; and per-season championship standings.

The scraper covers **76+ years of F1 history** with structured records across 9 endpoints. Filters run server-side, so a single run can isolate every Verstappen win, every Ferrari race in 2024, or the complete 1976 championship standings.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| F1 journalists, sports-analytics teams, fantasy F1 platforms, ML pipelines, broadcast researchers, fan communities | Sports analytics, F1 fantasy app data, broadcast production research, betting and odds platforms, content marketing on F1 |

---

### 📋 What the F1 Race Results and Standings Scraper does

Five filtering workflows in a single run:

- 🏁 **Race results.** Positions, points, lap times, status per race.
- ⏱️ **Qualifying results.** Q1/Q2/Q3 times per driver per session.
- 🏆 **Championship standings.** Driver and constructor standings per round, per season.
- 👤 **Driver/constructor profiles.** One row per driver or team across all years.
- 🏟️ **Circuits + schedule.** All circuits with geo coordinates; per-season race schedule.

> 💡 **Why it matters:** clean, server-side filtering removes the parser-and-pagination work from your team and keeps your dataset fresh on every run.

---

### 🎬 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>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>endpoint</code></td><td>string</td><td><code>"results"</code></td><td>`results`, `qualifying`, `sprint`, `drivers`, `constructors`, `circuits`, `driverStandings`, `constructorStandings`, `races`.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>"2024"</code></td><td>Year, `current`, or empty for all.</td></tr>
<tr><td><code>round</code></td><td>string</td><td><code>""</code></td><td>Specific round number.</td></tr>
<tr><td><code>driverId</code></td><td>string</td><td><code>""</code></td><td>Driver filter (`max_verstappen`, `hamilton`).</td></tr>
<tr><td><code>constructorId</code></td><td>string</td><td><code>""</code></td><td>Constructor filter (`ferrari`, `mercedes`).</td></tr>
<tr><td><code>circuitId</code></td><td>string</td><td><code>""</code></td><td>Circuit filter (`monaco`, `silverstone`).</td></tr>
</tbody>
</table>

**Example: every 2024 race result.**

```json
{
    "maxItems": 500,
    "endpoint": "results",
    "season": "2024"
}
````

**Example: Verstappen all-time wins.**

```json
{
    "maxItems": 100,
    "endpoint": "results",
    "driverId": "max_verstappen"
}
```

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📅 `season` | string | `"2024"` |
| 🔢 `round` | string | `"1"` |
| 🏁 `raceName` | string | `"Bahrain Grand Prix"` |
| 📅 `date` | string | `"2024-03-02"` |
| 🏟️ `circuitName` | string | `"Bahrain International Circuit"` |
| 🌍 `country` | string | `"Bahrain"` |
| 🏆 `position` | string | `"1"` |
| ⭐ `points` | string | `"26"` |
| 🏃 `grid` | string | `"1"` |
| 👤 `driverName` | string | `"Max Verstappen"` |
| 🏷️ `driverNationality` | string | `"Dutch"` |
| 🏎️ `constructorName` | string | `"Red Bull"` |
| ⏱️ `timeOrStatus` | string | `"1:31:44.742"` |
| ⚡ `fastestLap` | string | null | `"1:32.608"` |
| 🔗 `wikipediaUrl` | string | `"https://en.wikipedia.org/wiki/2024_Bahrain_Grand_Prix"` |

#### 📦 Sample records

<details>
<summary><strong>🏆 P1 win</strong></summary>

```json
{"season":"2024","round":"1","raceName":"Bahrain Grand Prix","date":"2024-03-02","position":"1","points":"26","driverName":"Max Verstappen","constructorName":"Red Bull","timeOrStatus":"1:31:44.742"}
```

</details>

<details>
<summary><strong>🏎️ P3 finish</strong></summary>

```json
{"season":"2024","round":"1","raceName":"Bahrain Grand Prix","position":"3","points":"15","driverName":"Carlos Sainz","constructorName":"Ferrari","timeOrStatus":"+25.110"}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📚 | **76+ years of F1.** 1950 to present, every race result and championship standing. |
| 🔄 | **9 endpoints.** Results, qualifying, sprint, drivers, constructors, circuits, standings, schedule. |
| 🌐 | **Geo-tagged.** Circuit lat/lng for map overlays. |
| ⚡ | **Fast.** 100 records in under 20 seconds. |
| 🆓 | **No quota.** Public open-data backend, no key required. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **1950 to present** | Live per run | 9 endpoints, 6 filters | ⚡ 2 min |
| Manual Wikipedia scraping | Free | All | Variable | DIY | 🐢 Days |
| Sports-data APIs | $200+/month | Live | Live | Many | 🐢 Account |
| CSV dump downloads | Free | Variable | Stale | None | 🐢 ETL |

Pick this Actor when you want broad coverage, server-side filtering, and no pipeline maintenance.

***

### 🚀 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 F1 Race Results and Standings Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick your filters 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

- Driver-vs-driver historical comparisons
- Team performance over decades
- Circuit-specific win patterns
- Track-record analysis

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

#### 🎮 Fantasy F1 / Betting

- Train ML models on historical data
- Build odds and prediction features
- Power fantasy F1 leaderboards
- Run season-simulation engines

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

#### 📰 Sports Journalism

- Race-week stat packages
- Driver retirement features
- Constructor history articles
- Championship-decided pieces

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

#### 🏎️ Broadcast & Fan Apps

- Live commentary stat overlays
- Build fan-engagement dashboards
- Build retro F1 viewing apps
- Power F1 history podcasts

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

***

### 🔌 Automating F1 Race Results and 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 on any cron interval. Hourly, daily, or weekly refreshes 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-economics research
- Performance analysis studies
- Reproducible F1 data snapshots
- Coursework on time-series analysis

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

#### 🎨 Personal and creative

- Personal F1 dashboards
- Side projects on race data
- Fan blogs and newsletters
- Hobbyist visualizations

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

#### 🤝 Non-profit and civic

- Sports inclusion research
- Driver diversity studies
- Open sports-data contributions
- Educational stats projects

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

#### 🧪 Experimentation

- Train race-prediction models
- Prototype F1-aware agents
- Build position-change visualizations
- Test sports analytics libraries

</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%20F1%20Race%20Results%20and%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%20F1%20Race%20Results%20and%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%20F1%20Race%20Results%20and%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%20F1%20Race%20Results%20and%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

#### 🧩 How does it work?

Pick an endpoint and optional filters (season, round, driver, constructor, circuit). The Actor queries the public Ergast/Jolpica F1 backend and emits structured records.

#### 📅 How far back does data go?

1950, the first F1 season. Every race, qualifying session, and championship is included.

#### 🏁 What's the difference between endpoints?

Each endpoint returns a different table: results (per-race), qualifying (Q1-Q3 times), sprint, drivers (per driver), constructors (per team), circuits, standings (driver/constructor), races (schedule).

#### 📊 How many fields per record?

Up to 34 fields per race-result row. Other endpoints return correspondingly different schemas.

#### 🔁 Can I schedule runs?

Yes. Use Apify Schedules to refresh standings after each Grand Prix or build a season-tracker.

#### ⚖️ Is this data public?

Yes. The Ergast Developer API and its Jolpica-hosted mirror publish F1 data under an open license.

#### ⏱️ Are lap times included?

Yes for race results (`timeOrStatus`, `fastestLap`). Per-lap data is available on a separate endpoint via the laps query.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs. A paid plan unlocks higher item counts and scheduling.

#### 🆘 What if a run fails?

Apify retries transient errors. Partial datasets are preserved.

#### 🌐 Does it cover sprint races?

Yes. Set `endpoint` to `sprint` for sprint results.

***

### 🔌 Integrate with any app

F1 Race Results and 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 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

- [**🌏 World Bank Indicators**](https://apify.com/parseforge/worldbank-indicators-scraper) - Country economic indicators across 60+ years
- [**🌐 Wikidata Entity Search**](https://apify.com/parseforge/wikidata-entity-search-scraper) - 100M+ open knowledge-graph entities
- [**📰 Hacker News Search**](https://apify.com/parseforge/hackernews-algolia-scraper) - Every HN story since 2007
- [**🎬 TVMaze TV Shows**](https://apify.com/parseforge/tvmaze-shows-scraper) - TV show metadata and episodes
- [**📊 Stack Exchange Questions**](https://apify.com/parseforge/stackexchange-questions-scraper) - Search 170+ Stack Exchange sites

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more 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 One Group, the FIA, the Ergast project, the Jolpica project, or any F1 team or driver. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

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

## `endpoint` (type: `string`):

Which F1 dataset to scrape.

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

Year (e.g. '2024'), 'current' for current season, or empty for all.

## `round` (type: `string`):

Specific round number (e.g. '5'). Optional.

## `driverId` (type: `string`):

Filter by driver (e.g. 'max\_verstappen', 'hamilton'). Optional.

## `constructorId` (type: `string`):

Filter by constructor (e.g. 'ferrari', 'mercedes', 'red\_bull'). Optional.

## `circuitId` (type: `string`):

Filter by circuit (e.g. 'monaco', 'silverstone'). Optional.

## Actor input object example

```json
{
  "maxItems": 10,
  "endpoint": "results",
  "season": "2024"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "endpoint": "results",
    "season": "2024",
    "round": "",
    "driverId": "",
    "constructorId": "",
    "circuitId": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/f1-ergast-results-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,
    "endpoint": "results",
    "season": "2024",
    "round": "",
    "driverId": "",
    "constructorId": "",
    "circuitId": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/f1-ergast-results-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,
  "endpoint": "results",
  "season": "2024",
  "round": "",
  "driverId": "",
  "constructorId": "",
  "circuitId": ""
}' |
apify call parseforge/f1-ergast-results-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "F1 Race Results and Standings Scraper",
        "description": "Pull Formula 1 race results, qualifying, sprint, drivers, constructors, circuits and championship standings from 1950 to present. Returns positions, points, lap times, fastest laps, grid positions and full driver/team metadata per race. Filter by season, round, driver, constructor or circuit.",
        "version": "1.0",
        "x-build-id": "LTI5yh1NVj4WfbrEE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~f1-ergast-results-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-f1-ergast-results-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~f1-ergast-results-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-f1-ergast-results-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~f1-ergast-results-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-f1-ergast-results-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": {
                    "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"
                    },
                    "endpoint": {
                        "title": "Endpoint",
                        "enum": [
                            "results",
                            "qualifying",
                            "sprint",
                            "drivers",
                            "constructors",
                            "circuits",
                            "driverStandings",
                            "constructorStandings",
                            "races"
                        ],
                        "type": "string",
                        "description": "Which F1 dataset to scrape.",
                        "default": "results"
                    },
                    "season": {
                        "title": "Season (year)",
                        "type": "string",
                        "description": "Year (e.g. '2024'), 'current' for current season, or empty for all."
                    },
                    "round": {
                        "title": "Round",
                        "type": "string",
                        "description": "Specific round number (e.g. '5'). Optional."
                    },
                    "driverId": {
                        "title": "Driver ID",
                        "type": "string",
                        "description": "Filter by driver (e.g. 'max_verstappen', 'hamilton'). Optional."
                    },
                    "constructorId": {
                        "title": "Constructor ID",
                        "type": "string",
                        "description": "Filter by constructor (e.g. 'ferrari', 'mercedes', 'red_bull'). Optional."
                    },
                    "circuitId": {
                        "title": "Circuit ID",
                        "type": "string",
                        "description": "Filter by circuit (e.g. 'monaco', 'silverstone'). Optional."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
