# League of Legends MCP Server - AI Game Analysis (`mrbridge/lol-mcp-server`) Actor

Connect AI assistants to League of Legends data via MCP. 26 tools for player profiles, ranked stats, match history, champion mastery, live game, league standings, clash, challenges & AI coaching. No Riot API key needed. Works with Claude Desktop, ChatGPT & any MCP-compatible AI agent.

- **URL**: https://apify.com/mrbridge/lol-mcp-server.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** AI, MCP servers, Integrations
- **Stats:** 23 total users, 6 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $10.00 / 1,000 ai analyses

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## 🎮 League of Legends MCP Server

League of Legends MCP Server connects AI assistants — Claude Desktop, ChatGPT, and any MCP-compatible agent — to live League of Legends data via the Model Context Protocol. Let AI analyze your games, find what's costing you LP, and coach you on your real numbers: **26 tools** covering player profiles, ranked stats, match history, champion mastery, live games, league standings, Clash, challenges, and AI-powered coaching.

Ask Claude *"Analyze my last 20 ranked games and tell me why I'm stuck in Bronze"* — it calls `lol_get_player_profile` and `lol_analyze_performance` and hands you a coaching report with strengths, weaknesses, and a climbing plan. **No Riot API key needed, no setup, no coding** — just connect and start analyzing.

### What is LoL MCP Server?

LoL MCP Server runs in Apify's Standby mode as a persistent server that conversational AI assistants — **Claude Desktop**, **ChatGPT**, and any MCP-compatible client — call to read and analyze any player's League of Legends data. Ask in plain language; the AI pulls your real numbers and coaches you on them.

- 🩺 **Performance diagnosis that names the leak** — deaths per game, CS economy, vision habits and KDA benchmarked against your rank, from your real ranked games
- 🎯 **A champion pool built for *your* playstyle** — not a generic tier list; recommendations grounded in the champions that actually win for you
- 📜 **Full match breakdowns** — KDA, damage, objectives, gold and minute-by-minute timelines, name-resolved via Data Dragon (no cryptic IDs)
- 📡 **Live & ladder intel** — scout live games, Challenger/GM/Master ladders, any tier page, Clash teams and challenge leaderboards
- ⚔️ **26 tools, 16 regions** — EUW to KR; AI analysis in English or French
- 🔑 **Zero setup, built-in Riot key** — no developer account, no 24-hour key to regenerate; connect and ask
- 🔌 **Speaks MCP over Streamable HTTP** — built for Claude Desktop, ChatGPT, and any MCP-compatible client
- ⚡ **Standby mode** — fast responses once warm; cold start adds ~5–10 s only on the first call after idle

### Quick Start — Connect in 2 minutes

**No Riot API key needed** — the server includes a built-in key. Your connection URL is the same for every client — replace `YOUR_APIFY_TOKEN` with your [Apify API token](https://console.apify.com/account/integrations):

````

https://mrbridge--lol-mcp-server.apify.actor/mcp?token=YOUR\_APIFY\_TOKEN

```

#### 1. Connect your AI assistant

- **Claude Desktop** — **Settings → Connectors → Add custom connector**, paste the URL above, save.
- **ChatGPT** (Plus / Pro / Team / Enterprise) — **Settings → Connectors**, enable **Developer mode**, **Add custom connector**, paste the URL, save. Also available in deep research.
- **Apify Universal MCP** — already using [`mcp.apify.com`](https://mcp.apify.com?fpr=mrbridge)? Skip the separate config and add this server as a tool: `https://mcp.apify.com?tools=mrbridge/lol-mcp-server`.

#### 2. Start asking questions

That's it! Try:
> "Look up the profile of Faker on KR and tell me his current rank"

The endpoint speaks Streamable HTTP at `/mcp` — there is no `/sse` endpoint.

### Real Example: AI coaching from your match history

Here is the kind of analysis Claude produces for a real player (Bronze III jungle main, EUW) over **50 ranked games** — using only this MCP server's tools, with no manual data entry.

**The diagnosis** (from `lol_analyze_performance`):
> Your problem isn't creating plays — 8.2 assists per game is above your rank's average. It's dying: 6.8 deaths per game against a sub-4.5 target, for a 1.61 KDA. And your farming collapses under pressure — 87 vs 262 CS in games of similar length, roughly 600–700 gold per game left on the table.

**What works vs what holds you back** (mastery and win rates cross-referenced):

| Champion | Ranked games | Win rate | Verdict |
|----------|--------------|----------|---------|
| Rammus | 41 | 44% | ⭐ statistically reliable main — keep |
| Udyr (M20, 271K pts) | 12 | 25% | 🚩 highest mastery, worst results — retrain first |
| Alistar | 7 | ~14% | 🚩 avoid until mechanics improve |

From there Claude drew the actionable plan: keep Rammus as primary with a backup for ban games, cut deaths by changing gank exits, stabilize the farming routine under pressure — then laid out ELO benchmarks and a **90-day improvement plan**.

> Every number above came from the player's real match history through this MCP server. Just ask your AI to analyze any Riot ID.

Try it yourself:
> "Analyze my last 20 ranked games and create a detailed performance report with a plan to climb. My Riot ID is YourName#TAG on EUW."

### Other MCP clients

**Any MCP-compatible client** speaks to the same Streamable HTTP endpoint (`/mcp`) with your Apify token in the `Authorization: Bearer` header or `?token=` query. This server is built for conversational assistants — Claude Desktop and ChatGPT are where game coaching shines.

#### Zapier, Make & n8n

LoL MCP Server runs on Apify, which integrates natively with automation platforms: use the [Apify Zapier integration](https://zapier.com/apps/apify), the [Apify Make integration](https://www.make.com/en/integrations/apify), or the [Apify n8n node](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/) with Actor ID `EC9IhPoWo8Z4mHPJU`. Example Zap: daily ranked-stats analysis posted to Discord.

### Authentication

All requests require an **Apify API token** ([get it here](https://console.apify.com/account/integrations)), passed either as the `?token=` query parameter or as an `Authorization: Bearer` header (preferred for production). An invalid token returns HTTP 401 and consumes nothing. No Riot API key is required — the server includes a built-in key.

### What tools are available? (26 tools)

#### Account & Profile

Billed as **Data Retrieval** ($0.003/call), except `lol_get_player_profile`, which bills as **Match Data** ($0.005/call).

| Tool | What it does |
|------|-------------|
| `lol_get_account` | Account by Riot ID; returns the PUUID used by other calls |
| `lol_get_summoner` | Summoner info (level, profile icon) by PUUID |
| `lol_get_ranked` | Ranked info (tier, rank, LP, win/loss) by PUUID |
| `lol_get_player_profile` | Complete profile (account + summoner + ranked) in one call — the recommended starting point |

#### Match Data

Billed as **Match Data** ($0.005/call).

| Tool | What it does |
|------|-------------|
| `lol_get_match_history` | Recent match IDs for a player |
| `lol_get_match_details` | Detailed match data with resolved champion, item and rune names |
| `lol_get_match_timeline` | Minute-by-minute timeline: gold differences, kills, objectives |

#### Champion Mastery

Billed as **Data Retrieval** ($0.003/call).

| Tool | What it does |
|------|-------------|
| `lol_get_champion_mastery` | Top champion masteries with points, levels and champion roles |
| `lol_get_mastery_by_champion` | Detailed mastery for one champion: level, points, progression, season milestones |

#### Live Game

Billed as **Match Data** ($0.005/call).

| Tool | What it does |
|------|-------------|
| `lol_get_live_game` | Check if a player is in game; live details: participants, champions, runes, spells |

#### Leagues & Ranked Ladders

Billed as **Data Retrieval** ($0.003/call).

| Tool | What it does |
|------|-------------|
| `lol_get_league_top` | Challenger, Grandmaster or Master league, sorted by LP |
| `lol_get_league_entries` | League entries by queue, tier and division (paginated) |
| `lol_get_league_by_id` | Full league by its UUID |
| `lol_get_league_entries_exp` | Paginated entries including apex tiers (Master+) |

#### Clash

Billed as **Data Retrieval** ($0.003/call).

| Tool | What it does |
|------|-------------|
| `lol_get_clash_player` | Clash registration info for a player (teams, positions) |
| `lol_get_clash_team` | Clash team: name, tier, captain and players |
| `lol_get_clash_tournaments` | Active Clash tournaments, by ID or by team |

#### Challenges

Billed as **Data Retrieval** ($0.003/call).

| Tool | What it does |
|------|-------------|
| `lol_get_challenges` | Challenge configurations, percentiles or leaderboards |
| `lol_get_player_challenges` | A player's challenge progression: points, categories, progress |

#### Utility

Billed as **Data Retrieval** ($0.003/call).

| Tool | What it does |
|------|-------------|
| `lol_get_champion_rotation` | Current free champion rotation |
| `lol_get_featured_games` | Featured (spectatable) high-level games currently running |
| `lol_get_server_status` | Server status for a region: incidents and maintenance |

#### AI Analysis

Billed as **AI Analysis** ($0.015/call).

| Tool | What it does |
|------|-------------|
| `lol_analyze_performance` | Recent performance: stats, strengths, weaknesses, rank-based tips |
| `lol_analyze_champion` | Performance on a specific champion with stats and tips |
| `lol_get_improvement_tips` | Personalized, actionable tips with current vs target values |
| `lol_compare_players` | Compare two players side by side: KDA, CS, vision, damage |

### What can AI do with your LoL data?

- **Post-game coaching** — "I just lost 3 games in a row. Analyze what went wrong."
- **Champion pool optimization** — "Which 3 champions should I focus on to climb fastest?"
- **Duo synergy analysis** — "Compare me and my duo partner. What are our strengths together?"
- **Live scouting** — "I'm in game right now. Scout my opponents."

### What does the output look like?

A sample response from `lol_analyze_performance`:

```

Performance Analysis: YourName#EUW (last 20 ranked games)
Overall: 12W 8L (60% WR) | Avg KDA: 2.8 | Avg CS/min: 6.4
Strengths: vision score above Gold average; strong early game
Weaknesses: deaths spike after 25 min; champion pool too wide
Recommendation: narrow your pool to Jinx (68% WR) and Kai'Sa (62% WR).

````

### Which regions are supported?

All 16 League of Legends regions, from `euw1` (Europe West) and `na1` to `kr` — the full list is in the input form. Configuration options: `defaultRegion` (default `euw1`), `defaultLanguage` (`en` or `fr`, used for AI analysis), `cacheEnabled` (default `true`).

### Standby mode & performance

The server runs in **Apify Standby mode** — a persistent HTTP server that stays warm between requests.

- **Cold start:** ~5–10 seconds on the first request after inactivity; requests are fast while warm.
- **Idle timeout:** 5 minutes without requests, then the server shuts down; the next request triggers another cold start.
- **No idle cost for you:** billing is per tool call only — you pay nothing while the server sits idle.

### How much does it cost?

LoL MCP Server uses a **pay-per-event** pricing model: your AI assistant's tool calls are billed under three events — **Data Retrieval**, **Match Data**, and **AI Analysis** — and you're charged only on successful calls. See the [Pricing tab](https://apify.com/mrbridge/lol-mcp-server/pricing?fpr=mrbridge) for the live price table by Apify subscription tier.

A typical session — one profile check plus a 20-match performance analysis — costs about **$0.04**.

**What is NOT charged:** failed tool calls are never billed.

**Cost cap:** you can cap spending with Apify's maximum total charge limit (`ACTOR_MAX_TOTAL_CHARGE_USD`). Once the cap is reached, further tool calls are rejected instead of billing past your limit.

### FAQ

#### Do I need a Riot API key?
No. The server includes a built-in Riot API key. You can start immediately without a Riot developer account.

#### Why is my first request slow?
Cold start — after 5 idle minutes the server shuts down and the next request takes ~5–10 s to spin it up (see [Standby mode](#standby-mode--performance)).

#### Does this work with ChatGPT?
Yes — via Developer-mode connectors and deep research (see [Quick Start](#quick-start--connect-in-2-minutes)). Claude Desktop and any MCP-compatible client work too.

#### What rate limits apply?
The server respects Riot Games API limits (20 requests/second, 100 requests/2 minutes) with an internal rate limiter and caching, so bursts of tool calls are queued rather than failing.

#### What happens when I hit my spending cap?
Subsequent tool calls return an error instead of being billed. You are never charged beyond your cap.

#### Can I analyze other players?
Yes. Any player's public data can be looked up by Riot ID (gameName#tagLine) — no special permission is needed for public data.

#### Is my data stored?
No. Requests are processed in real time; no player data is stored permanently. All data comes directly from Riot Games' official API.

#### How do I see my usage and costs?
In the Apify Console under [Billing → Usage](https://console.apify.com/billing), filtered by this Actor.

### Other MCP servers by mrbridge

| Server | Category | Tools | Best for |
|---|---|---|---|
| [ESPN MCP Server](https://apify.com/mrbridge/espn-mcp-server?fpr=mrbridge) | Sports | 13 tools | Live scores, standings & stats for 25+ leagues |
| [TFT MCP Server](https://apify.com/mrbridge/tft-mcp-server?fpr=mrbridge) | Gaming | 19 tools | Teamfight Tactics comp analysis & coaching |
| [Latest News MCP](https://apify.com/mrbridge/latest-news-mcp-server?fpr=mrbridge) | News | 14 tools | Real-time news from 27 free APIs |
| [Todoist AI Assistant](https://apify.com/mrbridge/todoist-ai-assistant?fpr=mrbridge) | Productivity | 35 tools | Smart task management & AI prioritization |

All servers use pay-per-event pricing. $5 free credits/month included.

### Built by MrBridge

This MCP server is built by **MrBridge** — see the [LoL MCP server overview](https://mr-bridge.com/solutions/lol-mcp-server) or the [MCP server catalog](https://mr-bridge.com/mcp-servers). Learn more about what we do at [mr-bridge.com](https://mr-bridge.com).

### Resources

- [LoL MCP Server solution page](https://mr-bridge.com/solutions/lol-mcp-server)
- [Riot Developer Portal](https://developer.riotgames.com/)
- [Claude Desktop MCP Setup](https://docs.anthropic.com/en/docs/agents-and-tools/mcp)
- [Apify MCP Documentation](https://docs.apify.com/platform/integrations/mcp?fpr=mrbridge)

### Legal & responsible use

This Actor retrieves publicly available game data through the official Riot Games API. You are responsible for ensuring your use complies with the [Riot Games API Terms of Service](https://developer.riotgames.com/terms) and applicable data-protection regulation. LoL MCP Server is not endorsed by and is not affiliated with Riot Games; League of Legends is a trademark of Riot Games, Inc.

#### Your feedback

Found a bug or have a feature request? Open an issue on the [Issues tab](https://apify.com/mrbridge/lol-mcp-server/issues?fpr=mrbridge) — we read every report.

---

**Built with ❤️ for the League of Legends community**

# Actor input Schema

## `defaultRegion` (type: `string`):

Select your primary game server.
## `defaultLanguage` (type: `string`):

Language for AI-generated analysis and recommendations.
## `cacheEnabled` (type: `boolean`):

Cache reduces API calls and improves response times. Recommended: enabled.

## Actor input object example

```json
{
  "defaultRegion": "euw1",
  "defaultLanguage": "en",
  "cacheEnabled": true
}
````

# Actor output Schema

## `runUrl` (type: `string`):

Link to the Actor run details page

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/lol-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/lol-mcp-server").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 '{}' |
apify call mrbridge/lol-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "League of Legends MCP Server - AI Game Analysis",
        "description": "Connect AI assistants to League of Legends data via MCP. 26 tools for player profiles, ranked stats, match history, champion mastery, live game, league standings, clash, challenges & AI coaching. No Riot API key needed. Works with Claude Desktop, ChatGPT & any MCP-compatible AI agent.",
        "version": "2.0",
        "x-build-id": "ZUtbAULDPs8xeFOJH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mrbridge~lol-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mrbridge-lol-mcp-server",
                "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/mrbridge~lol-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-mrbridge-lol-mcp-server",
                "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/mrbridge~lol-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-mrbridge-lol-mcp-server",
                "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": {
                    "defaultRegion": {
                        "title": "Default Region",
                        "enum": [
                            "euw1",
                            "eun1",
                            "na1",
                            "kr",
                            "br1",
                            "la1",
                            "la2",
                            "oc1",
                            "tr1",
                            "ru",
                            "jp1",
                            "ph2",
                            "sg2",
                            "th2",
                            "tw2",
                            "vn2"
                        ],
                        "type": "string",
                        "description": "Select your primary game server.",
                        "default": "euw1"
                    },
                    "defaultLanguage": {
                        "title": "Default Language",
                        "enum": [
                            "en",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for AI-generated analysis and recommendations.",
                        "default": "en"
                    },
                    "cacheEnabled": {
                        "title": "Enable Cache",
                        "type": "boolean",
                        "description": "Cache reduces API calls and improves response times. Recommended: enabled.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
