# Understat xG & Shot Data - Football Analytics (`constructive_calm/understat-football-analytics`) Actor

Scrapes Understat: player/team season aggregates, per-match xG/PPDA/win-probabilities, shot-level data with x/y coords + xG, situation/formation/game-state breakdowns, player career histories, and fixtures across the Big 5 + RFPL (2014–2025). Multi-season + multi-league in a single run.

- **URL**: https://apify.com/constructive\_calm/understat-football-analytics.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** Agents, Developer tools, Other
- **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.80 / 1,000 player-season aggregate rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Understat xG & Shot Data — Football Analytics

Scrapes [understat.com](https://understat.com/): player and team season aggregates, per-match xG/PPDA/win-probabilities, **shot-level data with x/y coordinates**, situation/formation/game-state breakdowns, player career multi-season histories, and upcoming fixtures across the Big 5 European leagues + RFPL (2014/15 → 2025/26).

### Why this actor

Most Understat scrapers stop at league-level aggregates. This one exposes every data tier Understat has, in a single run, with multi-season + multi-league support out of the box.

| Workload | Typical alternative | This actor |
|---|---|---|
| EPL one-season player stats (~600 players) | $0.59 | **$0.59** (parity) |
| All 6 leagues × one season player stats | $3.04 | **~$2.99** |
| 5 years EPL player stats in one run | impossible (5 separate runs) | **~$2.95** |
| Shot-level data, EPL one season (~9,500 shots) | unavailable | **~$7.22** |
| Every EPL match + shots in one run | unavailable | **~$7.22** |

Pricing is pure pay-per-event. Per-row meters mean you pay for what you extract — no per-run fee, no per-league surcharge.

### Modes

Pick a mode to determine what the actor scrapes:

| Mode | What you get | Source |
|---|---|---|
| `league_players` | One row per (player × season). xG, xA, npxG, xGChain, xGBuildup, per-90 derivations, position, appearances. | `/league/{LEAGUE}/{SEASON}` HTML or `/main/getPlayersStats/` POST when filters are set |
| `league_teams` | One row per (team × season). W/D/L, GF/GA, xG/xGA, npxG/npxGA, npxGD, PPDA, deep, points, xPoints. | `/league/{LEAGUE}/{SEASON}` (aggregated from per-match `history` array) |
| `league_matches` | One row per played match. Score, xG home/away, win-probability forecast. | `/league/{LEAGUE}/{SEASON}` `datesData` |
| `match_shots` ⭐ | One row per shot. x/y normalized pitch coordinates, xG model value, situation, body part, result, derived distance and angle, score at time of shot. | `/match/{ID}` (parses `shotsData` + `match_info`) |
| `team_situations` | Long-format: one row per (team × season × breakdown × label). Covers situation (OpenPlay/SetPiece/Corner/FreeKick/Penalty), formation (4-3-3 etc), gameState (leading/tied/trailing), timing, shotZones, attackSpeed, result. | `/team/{TEAM}/{SEASON}` `statisticsData` |
| `player_career` | One row per (player × every season the player appears in). Full multi-season trajectory for any player ID. | `/player/{ID}` `playersData` |
| `fixtures` | One row per upcoming match. Date/time, teams, pre-match win-probability forecast (xG fields are null until played). | `/league/{LEAGUE}/{SEASON}` `datesData` (isResult=false) |

⭐ **`match_shots`** is the killer feature — most scrapers don't expose it.

### Pricing

| Event | Price |
|---|---|
| `league-season-scraped` | $0.01 — one league × one season "discovery" fetch |
| `team-season-scraped` | $0.005 |
| `player-season-scraped` | $0.0008 |
| `match-scraped` | $0.004 |
| `shot-scraped` | $0.0006 |
| `situation-breakdown-scraped` | $0.003 |
| `player-career-scraped` | $0.0008 |
| `fixture-scraped` | $0.0008 |

**No actor-start fee. No per-league surcharge.** First 100 chargeable events of every run are free — enough to taste every tier including a 75-shot heatmap and a multi-season career bundle.

### Cost cap

The `maxCostUsd` input (default **$25**) is a hard cap. The actor estimates cost up-front from your scope and warns you. Mid-run, every charge is checked against the cap; once hit, the run stops gracefully and writes a `cost_cap_reached` status row to the dataset.

Without this, a typo like *all 6 leagues × all 11 seasons × match_shots* could cost ~$375. With it, you're protected.

### Sample inputs

#### Player season stats (parity workload)

```json
{
    "mode": "league_players",
    "leagues": ["EPL"],
    "seasons": [2024]
}
````

#### Multi-season comparison (one run, not five)

```json
{
    "mode": "league_players",
    "leagues": ["EPL"],
    "seasons": [2020, 2021, 2022, 2023, 2024]
}
```

#### Forwards-only with date range

```json
{
    "mode": "league_players",
    "leagues": ["La_liga"],
    "seasons": [2024],
    "positions": ["F"],
    "dateStart": "2024-08-01",
    "dateEnd": "2024-12-31",
    "minAppearances": 5
}
```

#### Shot map for a single match

```json
{
    "mode": "match_shots",
    "matchIds": [26630]
}
```

#### All shots in a season (heavy — uses your cost cap)

```json
{
    "mode": "match_shots",
    "leagues": ["EPL"],
    "seasons": [2024],
    "maxCostUsd": 10
}
```

#### Mo Salah's complete career

```json
{
    "mode": "player_career",
    "playerIds": [1250]
}
```

#### Arsenal's situation breakdowns

```json
{
    "mode": "team_situations",
    "leagues": ["EPL"],
    "seasons": [2024],
    "teams": ["Arsenal"]
}
```

#### Upcoming Premier League fixtures

```json
{
    "mode": "fixtures",
    "leagues": ["EPL"],
    "seasons": [2025]
}
```

### Output

Every row carries:

- `type` — discriminator (`player_season`, `team_season`, `match`, `shot`, `team_situation`, `player_career_season`, `fixture`, or `status`)
- `_meta.mode` — which mode produced the row
- `_meta.scrapedAt` — ISO 8601 timestamp
- `_meta.source` — always `"understat"`

Set `includeRawJson: true` to attach the original Understat record under `_raw` (useful for power users; off by default to keep the dataset light).

### Resume

Long runs check-point progress to a named key-value store keyed by mode + input scope. If a run is interrupted, the next run with the same input picks up where it left off — already-completed (league × season) or (matchId) or (playerId) units are skipped.

### Limits

- **leagues × seasons ≤ 60** — protects against accidental over-scope (e.g. 6 × 11 = 66 league-seasons).
- **Cost cap** defaults to $25/run.
- **`match_shots`** throttles requests to 6 s between matches to mirror the empirically safe rate. Expect a full EPL season (~380 matches × ~25 shots) to take ~40 minutes.
- **RFPL** team names are Cyrillic — the actor URL-encodes them automatically.
- **Future fixtures** have null `xG` fields until played.

### Coverage

| League | Slug | Earliest season |
|---|---|---|
| English Premier League | `EPL` | 2014/15 |
| Spanish La Liga | `La_liga` | 2014/15 |
| German Bundesliga | `Bundesliga` | 2014/15 |
| Italian Serie A | `Serie_A` | 2014/15 |
| French Ligue 1 | `Ligue_1` | 2014/15 |
| Russian Premier League | `RFPL` | 2014/15 |

### Notes

- This actor scrapes a publicly accessible website. Be mindful of Understat's resources — the built-in throttle is conservative, and `match_shots` adds an extra delay because of its high fan-out.
- The xG values are Understat's neural-net model output. If you need the underlying training data or the model itself, you'll need to talk to them.
- Data freshness lags Understat's updates by minutes-to-hours depending on their crawl cadence.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. 'league\_players' returns per-player season aggregates (xG, xA, xGChain, xGBuildup, etc). 'league\_teams' returns team season aggregates (W/D/L, xG, xGA, PPDA, points, xPoints). 'league\_matches' returns played-match metadata (xG, win-prob, deep, ppda). 'match\_shots' returns every shot with x/y coords, xG, situation, body part, result. 'team\_situations' returns long-format breakdowns by situation/formation/game-state/timing/zones. 'player\_career' returns one player's full multi-season history. 'fixtures' returns upcoming matches.

## `leagues` (type: `array`):

One or more of the six leagues Understat covers. Required for league\_\*, match\_shots (when matchIds is empty), team\_situations (when teams is empty), and fixtures.

## `seasons` (type: `array`):

List of season start years. 2024 = 2024/25 season. Understat history goes back to 2014 (the 2014/15 season). Multi-season is supported in a single run — pull 11 years of EPL in one go instead of 11 separate invocations.

## `teams` (type: `array`):

Team names exactly as Understat displays them — e.g. 'Arsenal', 'Manchester United', 'Real Madrid', 'Зенит'. Spaces become underscores in URLs automatically. Used by team\_situations to filter to specific teams.

## `matchIds` (type: `array`):

Specific match IDs to scrape directly (used by match\_shots). When set, leagues/seasons are ignored. Find IDs in Understat URLs: /match/{ID}.

## `playerIds` (type: `array`):

Player IDs for player\_career mode. Find IDs in Understat URLs: /player/{ID}. Examples: 553 (Messi), 619 (Agüero), 1250 (Salah), 8260 (Haaland).

## `positions` (type: `array`):

Filter players by position. Only applies to league\_players mode (uses Understat's filtered POST endpoint).

## `nLastMatches` (type: `integer`):

Filter player stats to the last N matches. 0 = full season. Only applies to league\_players mode.

## `dateStart` (type: `string`):

Restrict league\_players stats to matches on or after this date. Leave empty for none.

## `dateEnd` (type: `string`):

Restrict league\_players stats to matches on or before this date. Leave empty for none.

## `minAppearances` (type: `integer`):

Drop player rows where games played is below this threshold (client-side filter). 0 = no filter.

## `maxResults` (type: `integer`):

Stop emitting after this many dataset rows. 0 = unlimited (subject to maxCostUsd).

## `maxCostUsd` (type: `integer`):

Hard cap on the run's total billed amount. The actor estimates cost up-front and stops gracefully if the cap is hit mid-run. Default $25 protects you from accidental high-volume runs (e.g. all 6 leagues × 11 seasons of shots ≈ $375).

## `includeRawJson` (type: `boolean`):

When true, attach the original Understat record under `_raw` on every output row. Useful for power users / debugging. Default off — keeps the dataset light.

## `proxyConfiguration` (type: `object`):

Apify proxy. Understat does not block scrapers, but residential proxies help users behind corporate networks. Default = Apify residential.

## Actor input object example

```json
{
  "mode": "league_players",
  "leagues": [
    "EPL"
  ],
  "seasons": [
    "2024"
  ],
  "teams": [],
  "matchIds": [],
  "playerIds": [],
  "positions": [],
  "nLastMatches": 0,
  "dateStart": "",
  "dateEnd": "",
  "minAppearances": 0,
  "maxResults": 50,
  "maxCostUsd": 25,
  "includeRawJson": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset of Understat football analytics records.

# 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 = {
    "leagues": [
        "EPL"
    ],
    "seasons": [
        "2024"
    ],
    "teams": [],
    "matchIds": [],
    "playerIds": [],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/understat-football-analytics").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 = {
    "leagues": ["EPL"],
    "seasons": ["2024"],
    "teams": [],
    "matchIds": [],
    "playerIds": [],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/understat-football-analytics").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 '{
  "leagues": [
    "EPL"
  ],
  "seasons": [
    "2024"
  ],
  "teams": [],
  "matchIds": [],
  "playerIds": [],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call constructive_calm/understat-football-analytics --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Understat xG & Shot Data - Football Analytics",
        "description": "Scrapes Understat: player/team season aggregates, per-match xG/PPDA/win-probabilities, shot-level data with x/y coords + xG, situation/formation/game-state breakdowns, player career histories, and fixtures across the Big 5 + RFPL (2014–2025). Multi-season + multi-league in a single run.",
        "version": "1.0",
        "x-build-id": "7uMU5asDKlKZGVjLb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~understat-football-analytics/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-understat-football-analytics",
                "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/constructive_calm~understat-football-analytics/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-understat-football-analytics",
                "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/constructive_calm~understat-football-analytics/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-understat-football-analytics",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "league_players",
                            "league_teams",
                            "league_matches",
                            "match_shots",
                            "team_situations",
                            "player_career",
                            "fixtures"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'league_players' returns per-player season aggregates (xG, xA, xGChain, xGBuildup, etc). 'league_teams' returns team season aggregates (W/D/L, xG, xGA, PPDA, points, xPoints). 'league_matches' returns played-match metadata (xG, win-prob, deep, ppda). 'match_shots' returns every shot with x/y coords, xG, situation, body part, result. 'team_situations' returns long-format breakdowns by situation/formation/game-state/timing/zones. 'player_career' returns one player's full multi-season history. 'fixtures' returns upcoming matches.",
                        "default": "league_players"
                    },
                    "leagues": {
                        "title": "Leagues",
                        "type": "array",
                        "description": "One or more of the six leagues Understat covers. Required for league_*, match_shots (when matchIds is empty), team_situations (when teams is empty), and fixtures.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "EPL",
                                "La_liga",
                                "Bundesliga",
                                "Serie_A",
                                "Ligue_1",
                                "RFPL"
                            ],
                            "enumTitles": [
                                "Premier League (England)",
                                "La Liga (Spain)",
                                "Bundesliga (Germany)",
                                "Serie A (Italy)",
                                "Ligue 1 (France)",
                                "Russian Premier League"
                            ]
                        },
                        "default": []
                    },
                    "seasons": {
                        "title": "Seasons (start year)",
                        "type": "array",
                        "description": "List of season start years. 2024 = 2024/25 season. Understat history goes back to 2014 (the 2014/15 season). Multi-season is supported in a single run — pull 11 years of EPL in one go instead of 11 separate invocations.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "teams": {
                        "title": "Teams (titles)",
                        "type": "array",
                        "description": "Team names exactly as Understat displays them — e.g. 'Arsenal', 'Manchester United', 'Real Madrid', 'Зенит'. Spaces become underscores in URLs automatically. Used by team_situations to filter to specific teams.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "matchIds": {
                        "title": "Match IDs (skip enumeration)",
                        "type": "array",
                        "description": "Specific match IDs to scrape directly (used by match_shots). When set, leagues/seasons are ignored. Find IDs in Understat URLs: /match/{ID}.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "playerIds": {
                        "title": "Player IDs",
                        "type": "array",
                        "description": "Player IDs for player_career mode. Find IDs in Understat URLs: /player/{ID}. Examples: 553 (Messi), 619 (Agüero), 1250 (Salah), 8260 (Haaland).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "positions": {
                        "title": "Positions filter",
                        "type": "array",
                        "description": "Filter players by position. Only applies to league_players mode (uses Understat's filtered POST endpoint).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "GK",
                                "D",
                                "M",
                                "F",
                                "S",
                                "Sub"
                            ],
                            "enumTitles": [
                                "Goalkeeper",
                                "Defender",
                                "Midfielder",
                                "Forward",
                                "Striker",
                                "Substitute"
                            ]
                        },
                        "default": []
                    },
                    "nLastMatches": {
                        "title": "Last N matches",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Filter player stats to the last N matches. 0 = full season. Only applies to league_players mode.",
                        "default": 0
                    },
                    "dateStart": {
                        "title": "Date from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Restrict league_players stats to matches on or after this date. Leave empty for none.",
                        "default": ""
                    },
                    "dateEnd": {
                        "title": "Date to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Restrict league_players stats to matches on or before this date. Leave empty for none.",
                        "default": ""
                    },
                    "minAppearances": {
                        "title": "Minimum appearances",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop player rows where games played is below this threshold (client-side filter). 0 = no filter.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Stop emitting after this many dataset rows. 0 = unlimited (subject to maxCostUsd).",
                        "default": 0
                    },
                    "maxCostUsd": {
                        "title": "Max cost (USD per run)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the run's total billed amount. The actor estimates cost up-front and stops gracefully if the cap is hit mid-run. Default $25 protects you from accidental high-volume runs (e.g. all 6 leagues × 11 seasons of shots ≈ $375).",
                        "default": 25
                    },
                    "includeRawJson": {
                        "title": "Include raw Understat JSON",
                        "type": "boolean",
                        "description": "When true, attach the original Understat record under `_raw` on every output row. Useful for power users / debugging. Default off — keeps the dataset light.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Understat does not block scrapers, but residential proxies help users behind corporate networks. Default = Apify residential.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
