# FBref Scraper | Advanced Soccer Statistics (`parseforge/fbref-scraper`) Actor

Extract advanced soccer stats from FBref including xG, xA, progressive passes, player and team metrics, match logs, shot maps, and league tables. Cover top leagues worldwide for football analytics, tactical analysis, scouting workflows, and sports betting research projects.

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

## ⚽ FBref Soccer Statistics Scraper

> 🚀 **Export complete soccer player statistics in seconds.** Scrape **goals, assists, xG, progressive passes, and 20+ fields** for any league and season - Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, and Europa League. No API key needed.

> 🕒 **Last updated:** 2026-05-21 · **📊 22 fields** per record · **🌍 7 leagues** · **📅 Multiple seasons** · **⚽ 500+ players per league**

The **FBref Soccer Statistics Scraper** extracts player standard statistics from [FBref.com](https://fbref.com) - the industry-standard football analytics reference maintained by Sports Reference. Each run returns a complete dataset of player performance metrics including goals, assists, cards, expected goals (xG), expected assists (xA), progressive passes, and progressive carries.

Coverage spans the top seven European competitions: Premier League, La Liga, Bundesliga, Serie A, Ligue 1, UEFA Champions League, and Europa League. Choose any season in YYYY-YY format and the Actor downloads the full squad list with per-player stats in under 30 seconds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Football analysts, sports journalists, fantasy football managers, betting researchers, academic researchers, data scientists | League tables, player performance comparison, transfer value research, xG analysis, fantasy football optimization, betting models |

---

### 📋 What the FBref Soccer Statistics Scraper does

- ⚽ **Full squad export.** Every player who appeared in the league that season - 500+ per competition.
- 🏆 **Multi-league support.** Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, Europa League.
- 📅 **Any season.** Specify `2024-25`, `2023-24`, `2022-23`, or any historical season available on FBref.
- 📊 **Advanced metrics.** Goals, assists, xG, xA, progressive carries, progressive passes, cards, and more.
- 🔗 **Player profile URLs.** Direct links to each player's FBref page for further drill-down.
- 🌍 **Nationality data.** 3-letter nationality code for every player.

> 💡 **Why it matters:** FBref is the reference standard for football analytics. Building your own scraper means fighting Cloudflare on every request, writing HTML parsers, handling mid-table header rows, and refreshing data manually. This Actor handles all of it and delivers clean JSON, CSV, or Excel on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing Premier League 2024-25 stats in under 30 seconds._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>league</td><td>string (select)</td><td>premier-league</td><td>League to scrape. One of: premier-league, la-liga, bundesliga, serie-a, ligue-1, champions-league, europa-league.</td></tr>
<tr><td>season</td><td>string</td><td>2024-25</td><td>Season in YYYY-YY format (e.g. 2024-25, 2023-24, 2022-23).</td></tr>
<tr><td>maxItems</td><td>integer</td><td>20</td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
</tbody>
</table>

**Example - Premier League 2024-25:**
```json
{
  "league": "premier-league",
  "season": "2024-25",
  "maxItems": 100
}
````

**Example - Champions League 2023-24:**

```json
{
  "league": "champions-league",
  "season": "2023-24",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** FBref data represents season totals (cumulative stats), not per-match breakdowns. xG and progressive stats may be 0 for players with very limited minutes. The `season` field must match a season archived on FBref (e.g. 2024-25 ends in 2025).

***

### 📊 Output

Each record contains 22 fields:

| Field | Type | Description |
|---|---|---|
| 👤 `playerName` | string | Full player name |
| 🌍 `nationality` | string | 3-letter nationality code (e.g. ENG, BRA, FRA) |
| 🏟️ `team` | string | Club name for the season |
| 📌 `position` | string | Playing position(s) (e.g. FW, MF, DF, GK) |
| 🎂 `age` | integer | Age during the season |
| 🔗 `playerUrl` | string | Link to the player's FBref page |
| 🏆 `league` | string | League slug (e.g. premier-league) |
| 📅 `season` | string | Season string (e.g. 2024-25) |
| 🎮 `gamesPlayed` | integer | Total appearances |
| 🚀 `gamesStarted` | integer | Starting appearances |
| ⏱️ `minutesPlayed` | integer | Total minutes |
| ⚽ `goals` | integer | Goals scored |
| 🎯 `assists` | integer | Assists |
| 🟨 `yellowCards` | integer | Yellow cards |
| 🟥 `redCards` | integer | Red cards |
| 📈 `xG` | float | Expected Goals |
| 📊 `xA` | float | Expected Assists (xAG) |
| 🏃 `progressivePasses` | integer | Progressive passes |
| 🔀 `progressiveCarries` | integer | Progressive carries |
| 🕒 `scrapedAt` | string | ISO timestamp of extraction |
| ❌ `error` | string/null | Error message if extraction failed |

**Sample record (Tyler Adams, Premier League 2024-25):**

```json
{
  "playerName": "Tyler Adams",
  "nationality": "USA",
  "team": "Bournemouth",
  "position": "MF",
  "age": 25,
  "playerUrl": "https://fbref.com/en/players/2b09d998/Tyler-Adams",
  "league": "premier-league",
  "season": "2024-25",
  "gamesPlayed": 28,
  "gamesStarted": 21,
  "minutesPlayed": 1965,
  "goals": 0,
  "assists": 3,
  "yellowCards": 7,
  "redCards": 0,
  "xG": 1.6,
  "xA": 1.0,
  "progressivePasses": 76,
  "progressiveCarries": 14,
  "scrapedAt": "2026-05-21T21:54:35.403Z",
  "error": null
}
```

**Sample record (Simon Adingra, Premier League 2024-25):**

```json
{
  "playerName": "Simon Adingra",
  "nationality": "CIV",
  "team": "Brighton",
  "position": "FW,MF",
  "age": 22,
  "playerUrl": "https://fbref.com/en/players/4dcec659/Simon-Adingra",
  "league": "premier-league",
  "season": "2024-25",
  "gamesPlayed": 29,
  "gamesStarted": 12,
  "minutesPlayed": 1097,
  "goals": 2,
  "assists": 2,
  "yellowCards": 0,
  "redCards": 0,
  "xG": 2.5,
  "xA": 2.5,
  "progressivePasses": 18,
  "progressiveCarries": 50,
  "scrapedAt": "2026-05-21T21:54:35.403Z",
  "error": null
}
```

***

### ✨ Why choose this Actor

- ⚡ **Fast delivery** - Full league dataset in under 30 seconds
- 🛡️ **Cloudflare-resistant** - Reliable delivery even against aggressive bot protection
- 📊 **22 fields per player** - Goals, assists, xG, xA, progressive stats, cards, and more
- 🏆 **7 major competitions** - Premier League, La Liga, Bundesliga, Serie A, Ligue 1, UCL, UEL
- 📅 **Historical seasons** - Any season available on FBref
- 🔗 **Player links** - Direct FBref profile URLs for every player
- 💾 **Export-ready** - Download as CSV, Excel, JSON, or XML instantly

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual FBref | Third-party APIs |
|---|---|---|---|
| xG + xA data | ✅ | ✅ | Varies |
| Progressive stats | ✅ | ✅ | Rarely |
| Free to start | ✅ | ✅ | Usually no |
| No API key | ✅ | ✅ | No |
| Structured output | ✅ | ❌ | ✅ |
| CSV/Excel export | ✅ | Manual | Varies |
| All 7 leagues | ✅ | ✅ | Varies |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) - includes $5 credit
2. Open the **FBref Soccer Statistics Scraper** page on the Apify Store
3. Click **Try for free**
4. Set your league (e.g. `premier-league`) and season (e.g. `2024-25`)
5. Set `maxItems` (10 for a preview, 500+ for a full league dataset)
6. Click **Start** and wait 30 seconds
7. Download your data as CSV, Excel, JSON, or XML

***

### 💼 Business use cases

#### 📊 Football Analytics and Research

Build player performance dashboards, identify undervalued players through xG analysis, compare league difficulty, and model transfer value. Full historical data enables multi-season trend analysis.

#### 🎮 Fantasy Football Optimization

Pull current-season stats to build data-driven fantasy team selection tools. xG and xA are the strongest forward-looking indicators for future performance. Progressive carries and passes identify creative midfielders.

#### 📰 Sports Journalism

Back your match reports and transfer stories with data. Pull a league's top scorers, assist leaders, xG overperformers, or most progressive ball-carriers in seconds rather than manually copying from FBref tables.

#### 📉 Betting and Performance Modeling

Construct regression models using historical xG, progressive stats, and age profiles. Combine with match result data for expected points models, player projection systems, and in-play betting algorithms.

***

### 🔌 Automating FBref Soccer Statistics Scraper

Connect to 7,000+ apps without any code:

- **Zapier** - Trigger weekly stat refreshes, auto-update Google Sheets, post top scorers to Slack
- **Make (Integromat)** - Build multi-step workflows between FBref stats and your CRM or database
- **Slack** - Post weekly league stat summaries to a channel
- **Google Sheets** - Auto-populate live league stat tables
- **Airtable** - Build a searchable player performance database

***

### 🌟 Beyond business use cases

#### 🔬 Academic Research

- Compare expected vs. actual goals to study finishing ability
- Analyze progressive pass patterns across different tactical systems
- Study age curves for physical vs. technical stats

#### 🧑‍💻 Developer Projects

- Build a personal football analytics app
- Create a league comparison API
- Power a player similarity search engine

#### 📚 Education and Learning

- Teach data science concepts with real sports data
- Build visualization projects with Tableau or Power BI
- Demonstrate regression analysis with xG models

#### 🎨 Creative Projects

- Build a "FBref on a map" data visualization
- Create animated stat timelines for top players
- Design infographic templates from structured JSON data

***

### 🤖 Ask an AI assistant about this scraper

You can ask ChatGPT, Claude, or any AI assistant about this scraper:

> "I have FBref soccer stats as JSON with fields: playerName, nationality, team, position, age, gamesPlayed, minutesPlayed, goals, assists, xG, xA, progressivePasses, progressiveCarries. How do I find players who are xG overperformers - scoring more goals than their xG suggests?"

> "I have Premier League 2024-25 player stats exported from FBref. How do I build a scatter plot comparing xG vs actual goals in Python?"

***

### ❓ Frequently Asked Questions

#### ⚽ What leagues are supported?

Premier League, La Liga, Bundesliga, Serie A, Ligue 1, UEFA Champions League, and Europa League.

#### 📅 What seasons are available?

Any season available on FBref in YYYY-YY format: 2024-25, 2023-24, 2022-23, and earlier. Seasons must be at least partially complete and archived.

#### 📊 What does xG mean?

Expected Goals (xG) measures the quality of chances a player had - it's a statistical measure of how many goals a player was expected to score based on the quality of their shots. Higher xG means better scoring opportunities.

#### 🔗 What are progressive passes and carries?

Progressive passes are passes that move the ball at least 10 meters closer to the opponent's goal. Progressive carries are dribbles that move the ball at least 5 meters toward goal. Both are key creativity metrics.

#### 💸 Is there a free tier?

Yes - free users get 10 records per run as a preview. [Paid users](https://console.apify.com/sign-up?fpr=vmoqkp) can scrape up to 1,000,000 records.

#### 🔄 How current is the data?

The scraper retrieves the most recent archived version of FBref stats, typically within days of the live site. For completed seasons, data is final and identical to FBref's published stats.

#### 📥 What export formats are available?

JSON, CSV, Excel (XLSX), and XML via the Apify dataset export panel.

#### ⏱️ How long does a run take?

Typically 15-30 seconds for a full league dataset of 500+ players.

#### 🛡️ Does it work against bot protection?

Yes - the Actor uses a reliable retrieval mechanism that bypasses standard scraping blocks.

#### 🏃 Can I scrape multiple leagues in one run?

The current version scrapes one league per run. You can schedule parallel runs for different leagues using Apify's scheduler.

#### 🔑 Do I need any credentials or API keys?

No. FBref is a public website. No account or API key is required.

#### 📈 Can I get historical data for multiple seasons?

Yes - run the Actor once per season with the appropriate season string (e.g. `2023-24`, `2022-23`).

***

### 🔌 Integrate with any app

Apify connects to 7,000+ platforms:

**Analytics** - Google Data Studio, Tableau, Power BI, Metabase
**Storage** - Google Sheets, Airtable, Notion, PostgreSQL, BigQuery
**Automation** - Zapier, Make (Integromat), n8n, Pipedream
**Communication** - Slack, Discord, Microsoft Teams, email
**Data pipelines** - AWS S3, Google Cloud Storage, Azure Blob

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Transfermarkt Scraper](https://apify.com/parseforge/transfermarkt-scraper) | Player market values, transfer history, contract data |
| [SofaScore Scraper](https://apify.com/parseforge/sofascore-scraper) | Live scores, match results, and fixture data |
| [Basketball Reference Scraper](https://apify.com/parseforge/basketball-reference-scraper) | NBA player statistics from Basketball Reference |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for sports data, financial datasets, job boards, and more - all with the same clean output format.

***

> **⚠️ Disclaimer:** This Actor retrieves publicly available statistics from FBref.com. It is an independent tool, not affiliated with Sports Reference LLC. All data is sourced from the public FBref website and is subject to Sports Reference's terms of use. Use responsibly and in accordance with applicable terms.

# Actor input Schema

## `league` (type: `string`):

The soccer league to scrape player statistics from

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

Season in format YYYY-YY (e.g. 2024-25 for the 2024-25 season)

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

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

## Actor input object example

```json
{
  "league": "premier-league",
  "season": "2024-25",
  "maxItems": 20
}
```

# 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 = {
    "season": "2024-25",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fbref-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 = {
    "season": "2024-25",
    "maxItems": 20,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FBref Scraper | Advanced Soccer Statistics",
        "description": "Extract advanced soccer stats from FBref including xG, xA, progressive passes, player and team metrics, match logs, shot maps, and league tables. Cover top leagues worldwide for football analytics, tactical analysis, scouting workflows, and sports betting research projects.",
        "version": "1.0",
        "x-build-id": "NzTyLIj7RklBWDlg5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~fbref-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-fbref-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~fbref-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-fbref-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~fbref-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-fbref-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "league",
                    "season"
                ],
                "properties": {
                    "league": {
                        "title": "League",
                        "enum": [
                            "premier-league",
                            "la-liga",
                            "bundesliga",
                            "serie-a",
                            "ligue-1",
                            "champions-league",
                            "europa-league"
                        ],
                        "type": "string",
                        "description": "The soccer league to scrape player statistics from",
                        "default": "premier-league"
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Season in format YYYY-YY (e.g. 2024-25 for the 2024-25 season)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
