# Teamfight Tactics MCP Server - AI Game Analysis (`mrbridge/tft-mcp-server`) Actor

Connect AI assistants to Teamfight Tactics (TFT) data via MCP. 19 tools for player profiles, ranked stats, match history, live game, leaderboards, player comparison & AI placement coaching. Works in Claude Desktop, ChatGPT & any MCP client.

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

## Pricing

from $2.00 / 1,000 data retrievals

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

## Teamfight Tactics MCP Server

Connect AI assistants to Teamfight Tactics (TFT) data via Model Context Protocol. Let AI analyze your placements, find what's costing you LP & suggest comp, econ and positioning fixes. Access player profiles, match history, ranked stats, leaderboards & live games.

**No Riot API key needed, no setup, no coding.** Just connect your AI assistant and start analyzing.

### What is TFT MCP Server?

TFT 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 Teamfight Tactics data. Ask in plain language; the AI pulls your real numbers and coaches you on them.

- 🩺 **Placement diagnosis that names the leak** — avg placement, top-4 vs top-1 conversion, and the exact units, traits and econ habits costing you LP, from your real ranked games.
- 🧩 **Comps built for *your* playstyle** — not a generic tier list; recommendations grounded in the boards that actually place for you.
- 📜 **Full match breakdowns** — every 8-player lobby with placements, starred units, items, augments and traits, name-resolved (no cryptic IDs).
- 🏆 **Ladder & live intel** — scout Challenger/GM/Master, any tier's ladder, the Hyper Roll rated ladder, and live lobbies to spot the biggest threat mid-game.
- ⚔️ **Three queues, 16 regions** — ranked TFT, Hyper Roll and Double Up stats side by side, EUW to KR.
- 🔑 **Zero setup, built-in Riot key** — no developer account, no 24-hour key to regenerate. Connect and ask.
- 🔌 **Speaks MCP + OpenAPI 3.1.0** — built for Claude Desktop, ChatGPT, and any MCP-compatible AI assistant.
- ⚡ **Standby mode** — sub-second responses once warm; cold start adds ~5–20s only on the very first call.

### Quick Start — Connect in 2 minutes

**No Riot API key needed** — this Actor includes a built-in API key. **No key, no developer account, no 24-hour expiry.** Just connect and play!

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--tft-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.
- **Apify Universal MCP** — already using [`mcp.apify.com`](https://mcp.apify.com?fpr=mrbridge)? Skip the separate config and just add this server as a tool: `https://mcp.apify.com?tools=mrbridge/tft-mcp-server`.

#### 2. Start asking questions

That's it! Your assistant can now access Teamfight Tactics data. Try asking:
> "Look up the TFT profile of Kataamak#6015 on EUW and tell me their current rank and average placement."

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

Here is the kind of analysis Claude produces from a real player's ranked games (Gold III, EUW) — using only this MCP server's tools, with no manual data entry.

**The diagnosis** (from `tft_analyze_performance` over 20 games):
> Your problem isn't survival, it's conversion. You hit top-4 in 60% of games (strong for Gold) but only 5% top-1, with a 4.30 average placement. Two mechanical signals: you plateau at level 8 (avg 8.6) instead of pushing 9, and your damage is low (avg 94) — defensive boards that stall instead of closing.

**What works vs what holds you back** (units & traits cross-referenced):

| Element | Games | Avg placement | Verdict |
|---------|-------|---------------|---------|
| Corki | 8 | 3.38 | ⭐ best carry, by far |
| Fateweaver (trait) | 6 | 3.67 | ⭐ best trait |
| Brawler (trait) | 13 | 4.85 | 🚩 over-played, under-performing |
| Maokai | 8 | 5.50 | 🚩 worst unit |

**Per-game findings** (from `tft_get_match_history` + `tft_get_match_details`):
> Game 2 — finished 5th, dead at round 31 still level 7, with 52 gold unspent and a 1★ Corki carrying items. You had the gold to level and roll; it never hit the board.

From there Claude drew the actionable plan: stop defaulting to Brawler + Cho'Gath, commit all three items to one carry, cap defensive items at two, and push level 9 instead of dying on unspent gold — then it built **three full comps** (core units, items, level-by-level spike, positioning) tailored to that exact playstyle.

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

Try it yourself:
> "Analyze my recent TFT games and recommend 3 comps that fit my playstyle. My Riot ID is YourName#TAG on EUW."

### What tools are available?

Once connected, your AI assistant can use these 19 tools.

**Player & matches**

| Tool | Description |
|------|-------------|
| `tft_get_account` | Resolve a Riot ID (gameName#tagLine) to a player |
| `tft_get_player_profile` | Complete profile: account, level, ranked (TFT / Hyper Roll / Double Up) |
| `tft_get_summoner` | Summoner level & profile icon |
| `tft_get_ranked` | Ranked standings across TFT, Hyper Roll and Double Up |
| `tft_get_match_history` | Recent match IDs (supports date range & pagination) |
| `tft_get_match_details` | Full 8-player lobby: placement, traits, starred units, items, augments, Little Legend |
| `tft_get_live_game` | Check whether a player is in a live TFT game |

**Analysis & coaching**

| Tool | Description |
|------|-------------|
| `tft_analyze_performance` | Placement diagnosis: avg placement, top-4 / top-1 rate, best & worst units and traits |
| `tft_analyze_champion` | How a specific unit performs for you (placement, top-4 rate, common items) |
| `tft_get_improvement_tips` | Personalized, data-grounded improvement tips |
| `tft_compare_players` | Compare two players side by side |

**Ladders & platform**

| Tool | Description |
|------|-------------|
| `tft_get_league_top` | Apex ladders — Challenger / Grandmaster / Master |
| `tft_get_league_entries` | Any tier/division ladder page (e.g. Diamond I) |
| `tft_get_rated_ladder` | Hyper Roll rated ladder |
| `tft_get_league_by_id` | A full league by its id |
| `tft_get_status` | TFT server status (maintenances, incidents) |
| `tft_get_featured_games` | Featured spectatable TFT games |

> `tft_get_match_timeline` and `tft_get_champion_mastery` are exposed for compatibility but report "not available for TFT" — Riot provides no timeline or champion-mastery endpoint for Teamfight Tactics. These calls are free.

### Built by MrBridge

This MCP server is built by **MrBridge** — see the [TFT MCP server details](https://mr-bridge.com/solutions/tft-mcp-server) page or the [MrBridge MCP server catalog](https://mr-bridge.com/mcp-servers). New to the protocol? Read [what MCP is and why it matters](https://mr-bridge.com/articles/what-is-mcp-model-context-protocol). Learn more about what we do at [mr-bridge.com](https://mr-bridge.com).

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

- **Post-game coaching** — "I just dropped 200 LP. Analyze my last 10 games — am I repeating the same mistakes?"
- **Comp optimization** — "Based on my last 50 games, which comps give me the best average placement?"
- **Playstyle-fit comps** — "Give me 3 comps that fit how I play, with items, level-by-level spikes and positioning."
- **Live scouting** — "I'm in a game right now. Look up my lobby and tell me who's the biggest threat."

### What does the output look like?

A sample response from the `tft_get_player_profile` tool (analysis tools like `tft_analyze_performance` return the kind of diagnosis shown in [Real Example](#real-example-ai-coaching-from-your-match-history) above):

```

Player Profile: Kataamak#6015

Region: EUW
Level: 312

Ranked TFT:
Tier: Platinum IV | LP: 32
Wins (Top 4): 142 | Losses (Bottom 4): 131 | Top-4 Rate: 52%

Recent Form (last 10 games):
Placements: 2, 5, 1, 4, 7, 3, 4, 6, 2, 4
Avg Placement: 3.8 | Top-4: 7/10

```

### Which regions are supported?

All 16 TFT regions: `euw1` (Europe West), `eun1` (EUNE), `na1` (North America), `kr` (Korea), `br1` (Brazil), `la1` (LAN), `la2` (LAS), `oc1` (Oceania), `tr1` (Turkey), `ru` (Russia), `jp1` (Japan), `ph2` (Philippines), `sg2` (Singapore), `th2` (Thailand), `tw2` (Taiwan), `vn2` (Vietnam).

### How do I configure the server?

The server works with zero configuration. These optional settings let you tune defaults:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `defaultRegion` | string | `euw1` | Your primary game server |
| `defaultLanguage` | string | `en` | Language for AI analysis (`en` or `fr`) |
| `cacheEnabled` | boolean | `true` | Intelligent caching for faster responses |

### Is my data safe?

Player data is never stored — every request goes straight to Riot Games' official API using the built-in key, and the Actor complies with the [Riot Games API Terms of Service](https://developer.riotgames.com/terms).

### Troubleshooting

- **"Player Not Found"** — check the Riot ID format `gameName#tagLine` (e.g. `Kataamak#6015`), the region, and that the player hasn't recently renamed.
- **Claude Desktop won't connect** — use the full `/mcp` URL `https://mrbridge--tft-mcp-server.apify.actor/mcp?token=YOUR_TOKEN`, verify your [Apify token](https://console.apify.com/account/integrations), and restart Claude Desktop. The first request after idle takes ~5–20s (cold start).

### How much does it cost?

TFT 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/tft-mcp-server/pricing?fpr=mrbridge) for the live price table by Apify subscription tier.

A typical session — one profile check plus a 20-game placement analysis — costs about **$0.04**. There are no idle costs.

**What is NOT charged:** failed tool calls and error responses are never billed, and the two compatibility stubs (`tft_get_match_timeline`, `tft_get_champion_mastery`) are always free.

**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. This Actor includes a built-in, dedicated API key. You can start using it immediately — no Riot developer account, no key to paste, and no 24-hour expiry to manage.

#### Does this work with ChatGPT?
Yes. Any MCP-compatible AI client can connect to this server. It works with Claude Desktop, ChatGPT, and other AI agents that support the Model Context Protocol.

#### Can I analyze other players?
Yes. You can look up any player's public data by providing their Riot ID (gameName#tagLine). No special permissions are needed for public data.

#### Your feedback
We're always improving this Actor. If you've got technical feedback or found a bug, please open an issue on the Actor's [Issues tab](https://apify.com/mrbridge/tft-mcp-server/issues?fpr=mrbridge).

### Apify Universal MCP & other clients

Already running the [Apify Universal MCP](https://mcp.apify.com?fpr=mrbridge)? It proxies every registered Actor — include this server on your existing Universal MCP URL instead of managing a separate config entry:

```

https://mcp.apify.com?tools=mrbridge/tft-mcp-server

```

**Any other 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.

### Integrate with Zapier, Make & n8n

TFT MCP Server runs on Apify, so it plugs into automation platforms via the Actor ID `MlStLtYJbY5S4HItj`: the [Zapier](https://zapier.com/apps/apify), [Make](https://www.make.com/en/integrations/apify) and [n8n](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/) Apify integrations each expose a "Run Actor" step you can wire to Discord, Slack, Google Sheets, or 5,000+ other apps. Or call the run endpoint directly:

```

POST https://api.apify.com/v2/acts/mrbridge~tft-mcp-server/runs?token=YOUR\_APIFY\_TOKEN

````

**Example:** Daily at 9 AM → analyze a player's ranked placements → post a Discord summary.

### Use via Apify API

Call this server programmatically without an MCP client (Python users: drive `apify-client`'s `ApifyClient` the same way):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('mrbridge/tft-mcp-server').call({ defaultRegion: 'euw1' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
````

> **Note:** For real-time AI conversations, use the MCP connection (see [Quick Start](#quick-start--connect-in-2-minutes)). The Apify API is best for batch jobs and automation pipelines.

### Other MCP servers by mrbridge

| Server | Category | Tools | Best for |
|---|---|---|---|
| [LoL MCP Server](https://apify.com/mrbridge/lol-mcp-server?fpr=mrbridge) | Gaming | 26 tools | League of Legends coaching & live game data |
| [ESPN MCP Server](https://apify.com/mrbridge/espn-mcp-server?fpr=mrbridge) | Sports | 13 tools | Live scores, standings & stats for 25+ leagues |
| [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.

### Resources

- [Riot Developer Portal](https://developer.riotgames.com/)
- [Riot API Documentation](https://developer.riotgames.com/apis)
- [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. TFT MCP Server is not endorsed by and is not affiliated with Riot Games; Teamfight Tactics is a trademark of Riot Games, Inc.

***

**Built with ❤️ for the Teamfight Tactics 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/tft-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/tft-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/tft-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Teamfight Tactics MCP Server - AI Game Analysis",
        "description": "Connect AI assistants to Teamfight Tactics (TFT) data via MCP. 19 tools for player profiles, ranked stats, match history, live game, leaderboards, player comparison & AI placement coaching. Works in Claude Desktop, ChatGPT & any MCP client.",
        "version": "2.0",
        "x-build-id": "qpjEKUnY9xfmbEaS4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mrbridge~tft-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mrbridge-tft-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~tft-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-mrbridge-tft-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~tft-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-mrbridge-tft-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
