# Esports Tournament Roster Scraper (`jungle_synthesizer/esports-tournament-roster-scraper`) Actor

Scrape esports player rosters from Liquipedia across CS, Valorant, Dota 2, LoL, Rocket League and 30+ game wikis. Returns handle, real name, nationality, role, current team, full team history, status, and social handles.

- **URL**: https://apify.com/jungle\_synthesizer/esports-tournament-roster-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Games, Automation, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Liquipedia Esports Player Roster Scraper

Scrape esports player profiles from [Liquipedia](https://liquipedia.net), the canonical wiki for competitive gaming. Returns handle, real name, nationality, role, current team, full chronological team history, and social handles across CS, Valorant, Dota 2, League of Legends, Rocket League, and 30+ other game wikis.

---

### Liquipedia Esports Roster Scraper Features

- Pulls player profiles from any of 30+ Liquipedia game wikis in a single run
- Returns 30+ fields per profile, including the things you'd expect (handle, nationality, current team) and the cross-platform IDs you'd otherwise scrape one site at a time (Steam64, FACEIT, ESEA, ESL, GamersClub)
- Parses chronological team history from Liquipedia's `{{TH}}` template — every stint, every loan, every "inactive" stretch
- Surfaces social handles from 12 platforms — Twitter, Twitch, YouTube, Instagram, Facebook, TikTok, Reddit, Discord, Telegram, Bilibili, Douyin, plus the wiki's native FACEIT/ESEA links
- Pure JSON API — no browser, no proxy, no captcha solving
- Honours Liquipedia's API Terms of Use, including the 1 req / 2 second rate limit and identifying User-Agent

---

### Who Uses Liquipedia Roster Data?

- **Esports team managers** — scout free agents and track recent transfers across CS2, Valorant, and LoL without copy-pasting from 30 tabs
- **Sports-betting and odds platforms** — feed roster changes into match-prediction models the day they happen
- **Sponsorship and agency teams** — pull social-handle inventories for outreach lists, sliced by game and current team
- **Fantasy esports operators** — populate player pools for DraftKings Rocket-style products with normalized handles, real names, and active teams
- **Researchers and journalists** — answer questions like "every Brazilian CS pro born after 2002" without writing a wiki crawler from scratch

---

### How the Liquipedia Esports Roster Scraper Works

1. Pick one or more game wikis (defaults to the top 5: CS, Valorant, Dota 2, LoL, Rocket League).
2. The scraper hits Liquipedia's MediaWiki API with `generator=categorymembers + prop=revisions`, pulling up to 50 player profiles' wikitext per request.
3. Each profile's `{{Infobox player}}` template is parsed into a flat record — handle, real name, romanized name, nationality, birth date, role(s), current team, status, social handles, and cross-platform IDs.
4. Team history is parsed from `{{TH|date_from — date_to|TeamName|qualifier}}` rows and flattened into a single human-readable summary string. Profiles that use Liquipedia's `{{TeamHistoryAuto}}` placeholder return an empty history field — that data is computed at render time, not stored in wikitext.

---

### Input

```json
{
  "games": ["counterstrike", "valorant", "dota2"],
  "maxItems": 100,
  "contactEmail": "you@yourdomain.com"
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `games` | string\[] | `[counterstrike, valorant, dota2, leagueoflegends, rocketleague]` | Liquipedia wiki slugs to scrape. Pick from CS, Valorant, Dota 2, LoL, Rocket League, Mobile Legends, Apex, R6, Overwatch, StarCraft 2, Halo, CoD, Fortnite, TFT, Hearthstone, Smash, Heroes, osu!, Paladins, Free Fire, GeoGuessr, CrossFire, Deadlock, EA SPORTS FC, Wild Rift, Brawl Stars, World of Tanks, Trackmania, PUBG Mobile, and Fighting Games. |
| `maxItems` | integer | `15` | Maximum total profiles to return across all selected wikis. The default is conservative for the Apify tester. Production runs can set it to 1,000+ — a single CS pull at 50 records per request and 1 req / 2 s finishes a 5,000-player wiki in roughly four minutes. |
| `contactEmail` | string | `contact@orbtop.com` | Email embedded in the User-Agent header sent to Liquipedia. Liquipedia's API ToS asks for identifying contact info — change it to yours so support can reach you if rate-limit issues come up. |

#### Scrape one wiki, full roster

```json
{
  "games": ["counterstrike"],
  "maxItems": 5000,
  "contactEmail": "you@yourdomain.com"
}
```

#### Pull rosters across the top three esports

```json
{
  "games": ["counterstrike", "valorant", "leagueoflegends"],
  "maxItems": 500,
  "contactEmail": "you@yourdomain.com"
}
```

***

### Liquipedia Esports Roster Scraper Output Fields

```json
{
  "pageId": 142086,
  "wiki": "counterstrike",
  "game": "Counter-Strike",
  "handle": "NiKo",
  "realName": "Никола Ковач",
  "romanizedName": "Nikola Kovač",
  "nationality": "Bosnia and Herzegovina",
  "birthDate": "1997-02-16",
  "roles": "entry",
  "currentTeam": "Team Falcons",
  "status": "Active",
  "yearsActive": "2009 - Present",
  "otherIds": "NiKolinho, nIKOLINHO, NiKOLINHO, nik0k0, niko",
  "teamHistorySummary": "2015-03-04 → 2015-05-04 mousesports; 2015-05-04 → 2015-08-30 mousesports [inactive]; 2015-08-30 → 2017-02-19 mousesports; 2017-02-19 → 2020-10-28 FaZe Clan; 2020-10-28 → 2025-01-03 G2 Esports; 2025-01-03 → Present Team Falcons",
  "teamCount": 19,
  "twitterHandle": "NiKoCS_",
  "twitchHandle": "NiKo",
  "youtubeChannel": "@NiKo_cs",
  "instagramHandle": "csgoniko",
  "facebookHandle": "csgoNiKo",
  "tiktokHandle": "csgoniko1",
  "redditHandle": "",
  "discordHandle": "",
  "telegramHandle": "",
  "bilibiliId": "3632311203531669",
  "douyinHandle": "NIKO1602",
  "steamId64": "76561198041683378",
  "eseaId": "571970",
  "eslId": "",
  "faceitId": "19606e0c-137b-4885-a904-744fa12d25f6",
  "gamersclubId": "",
  "profileUrl": "https://liquipedia.net/counterstrike/NiKo",
  "scrapedAt": "2026-05-02T16:22:53.941Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `pageId` | number | Liquipedia page ID — stable identifier within a wiki |
| `wiki` | string | Liquipedia wiki slug (`counterstrike`, `valorant`, `dota2`, etc.) |
| `game` | string | Human-readable game name |
| `handle` | string | In-game player handle / nickname |
| `realName` | string | Real name in native script when present |
| `romanizedName` | string | Real name romanized to Latin script when applicable |
| `nationality` | string | Country of origin |
| `birthDate` | string | Date of birth in `YYYY-MM-DD` format when available |
| `roles` | string | Comma-separated player roles (`awp, rifle`, `mid, support`, `igl`, etc.) |
| `currentTeam` | string | Current team. Empty when Liquipedia uses the `{{PlayerTeamAuto}}` placeholder |
| `status` | string | Career status: `Active`, `Inactive`, `Retired`, or `Deceased` |
| `yearsActive` | string | Years-active span as displayed on the profile |
| `otherIds` | string | Comma-separated alternate handles or aliases |
| `teamHistorySummary` | string | Chronological team history as a single semicolon-delimited string of `YYYY-MM-DD → YYYY-MM-DD TeamName [qualifier]` rows |
| `teamCount` | number | Total number of teams in the player's career history |
| `twitterHandle` | string | Twitter / X handle without `@` |
| `twitchHandle` | string | Twitch channel name |
| `youtubeChannel` | string | YouTube channel handle or ID |
| `instagramHandle` | string | Instagram handle |
| `facebookHandle` | string | Facebook page slug |
| `tiktokHandle` | string | TikTok handle |
| `redditHandle` | string | Reddit username |
| `discordHandle` | string | Discord handle |
| `telegramHandle` | string | Telegram username |
| `bilibiliId` | string | Bilibili user ID |
| `douyinHandle` | string | Douyin handle |
| `steamId64` | string | Steam community ID (64-bit) |
| `eseaId` | string | ESEA player ID, when set (Counter-Strike profiles) |
| `eslId` | string | ESL player ID, when set |
| `faceitId` | string | FACEIT user UUID |
| `gamersclubId` | string | GamersClub player ID (Brazilian CS profiles) |
| `profileUrl` | string | Full URL to the Liquipedia player profile page |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was scraped |

***

### FAQ

#### How do I scrape Liquipedia player profiles?

Liquipedia Esports Roster Scraper does it for you. Pick the game wikis you want from the dropdown, set a record cap, and run. The scraper hits Liquipedia's MediaWiki API directly and parses the `{{Infobox player}}` template into a flat JSON record, so you don't have to learn how to balance template braces by hand.

#### What esports does this actor cover?

Liquipedia Esports Roster Scraper covers every game with a Liquipedia wiki — CS, Valorant, Dota 2, League of Legends, Rocket League, Mobile Legends, Apex Legends, Rainbow Six, Overwatch, StarCraft 2, Halo, Call of Duty, Fortnite, Teamfight Tactics, Hearthstone, Super Smash Bros., Heroes of the Storm, osu!, Paladins, Free Fire, GeoGuessr, CrossFire, Deadlock, EA SPORTS FC, Wild Rift, Brawl Stars, World of Tanks, Trackmania, PUBG Mobile, and Fighting Games. Liquipedia adds new wikis periodically — re-run with the latest enum to pick them up.

#### How much does the Liquipedia Esports Roster Scraper cost to run?

Liquipedia Esports Roster Scraper costs $0.10 per run start plus $0.001 per record. A 1,000-record pull is about $1.10. A 5,000-player Counter-Strike full-roster sync is about $5.10. There are no hidden proxy fees because the actor does not use a proxy.

#### Why does `currentTeam` come back empty for some players?

Liquipedia Esports Roster Scraper returns an empty `currentTeam` when the wiki uses the `{{PlayerTeamAuto}}` template, which auto-resolves at render time from match data — not from anything stored in the page wikitext. Pulling that field would require Liquipedia's `action=parse` endpoint, which is rate-limited at one request every thirty seconds and would slow a 5,000-player crawl down by a factor of 60. The wikitext-derived `teamHistorySummary` field still includes their full history, including the most recent stint, so you can reconstruct the current team from there.

#### Does the Liquipedia Esports Roster Scraper need proxies?

Liquipedia Esports Roster Scraper does not need proxies. It hits Liquipedia's public API directly with a polite User-Agent that identifies the run, and respects the 1 request / 2 seconds rate limit baked into the API ToS. Liquipedia welcomes API traffic as long as you behave — proxies would obscure that, which is the opposite of what they ask for.

#### Can I run this on a schedule?

Liquipedia Esports Roster Scraper can run on any Apify schedule. Liquipedia profiles are wiki-edited daily for active rosters, so a weekly or twice-weekly schedule on the top 5 wikis is enough to keep a roster dataset reasonably fresh.

***

### Need More Features?

Need additional fields, a different target site, or a custom mode? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use the Liquipedia Esports Roster Scraper?

- **Affordable** — $0.001 per record, no proxy surcharge
- **Multi-game in one actor** — one input array picks any combination of 30+ game wikis, instead of running one scraper per game and reconciling the schemas yourself
- **Clean structured output** — flat JSON with consistent field names across every wiki, so a CS profile and a Valorant profile come back in the same shape and your downstream code doesn't care which game it's looking at

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `games` (type: `array`):

Which Liquipedia game wikis to scrape. Each wiki has its own player roster. Defaults to the top 5 esports titles.

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

Maximum total number of player profiles to return across all selected game wikis. Keep at 15 or below for the Apify tester (5-min timeout). Set higher for production runs.

## `contactEmail` (type: `string`):

Email address embedded in the User-Agent header sent to Liquipedia, per their API Terms of Use. Identifies your run for support and rate-limit issues.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "games": [
    "counterstrike",
    "valorant",
    "dota2",
    "leagueoflegends",
    "rocketleague"
  ],
  "maxItems": 15,
  "contactEmail": "contact@orbtop.com"
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "games": [
        "counterstrike",
        "valorant",
        "dota2",
        "leagueoflegends",
        "rocketleague"
    ],
    "maxItems": 15,
    "contactEmail": "contact@orbtop.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/esports-tournament-roster-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "games": [
        "counterstrike",
        "valorant",
        "dota2",
        "leagueoflegends",
        "rocketleague",
    ],
    "maxItems": 15,
    "contactEmail": "contact@orbtop.com",
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/esports-tournament-roster-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "games": [
    "counterstrike",
    "valorant",
    "dota2",
    "leagueoflegends",
    "rocketleague"
  ],
  "maxItems": 15,
  "contactEmail": "contact@orbtop.com"
}' |
apify call jungle_synthesizer/esports-tournament-roster-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Esports Tournament Roster Scraper",
        "description": "Scrape esports player rosters from Liquipedia across CS, Valorant, Dota 2, LoL, Rocket League and 30+ game wikis. Returns handle, real name, nationality, role, current team, full team history, status, and social handles.",
        "version": "1.0",
        "x-build-id": "hJB8kGtKSivdfTVzu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~esports-tournament-roster-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-esports-tournament-roster-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/jungle_synthesizer~esports-tournament-roster-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-esports-tournament-roster-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/jungle_synthesizer~esports-tournament-roster-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-esports-tournament-roster-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": [
                    "games"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "games": {
                        "title": "Liquipedia Game Wikis",
                        "type": "array",
                        "description": "Which Liquipedia game wikis to scrape. Each wiki has its own player roster. Defaults to the top 5 esports titles.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "counterstrike",
                                "valorant",
                                "dota2",
                                "leagueoflegends",
                                "rocketleague",
                                "mobilelegends",
                                "apexlegends",
                                "rainbowsix",
                                "overwatch",
                                "starcraft2",
                                "pubgmobile",
                                "fighters",
                                "halo",
                                "callofduty",
                                "fortnite",
                                "tft",
                                "worldoftanks",
                                "trackmania",
                                "hearthstone",
                                "smash",
                                "heroes",
                                "osu",
                                "paladins",
                                "freefire",
                                "geoguessr",
                                "crossfire",
                                "deadlock",
                                "easportsfc",
                                "wildrift",
                                "brawlstars"
                            ],
                            "enumTitles": [
                                "Counter-Strike (CS:GO / CS2)",
                                "VALORANT",
                                "Dota 2",
                                "League of Legends",
                                "Rocket League",
                                "Mobile Legends: Bang Bang",
                                "Apex Legends",
                                "Rainbow Six",
                                "Overwatch",
                                "StarCraft II",
                                "PUBG Mobile",
                                "Fighting Games",
                                "Halo",
                                "Call of Duty",
                                "Fortnite",
                                "Teamfight Tactics",
                                "World of Tanks",
                                "Trackmania",
                                "Hearthstone",
                                "Super Smash Bros.",
                                "Heroes of the Storm",
                                "osu!",
                                "Paladins",
                                "Free Fire",
                                "GeoGuessr",
                                "CrossFire",
                                "Deadlock",
                                "EA SPORTS FC",
                                "Wild Rift",
                                "Brawl Stars"
                            ]
                        },
                        "default": [
                            "counterstrike",
                            "valorant",
                            "dota2",
                            "leagueoflegends",
                            "rocketleague"
                        ]
                    },
                    "maxItems": {
                        "title": "Max Players",
                        "type": "integer",
                        "description": "Maximum total number of player profiles to return across all selected game wikis. Keep at 15 or below for the Apify tester (5-min timeout). Set higher for production runs.",
                        "default": 15
                    },
                    "contactEmail": {
                        "title": "Contact Email (User-Agent)",
                        "type": "string",
                        "description": "Email address embedded in the User-Agent header sent to Liquipedia, per their API Terms of Use. Identifies your run for support and rate-limit issues.",
                        "default": "contact@orbtop.com"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
