# Liquipedia Esports Wiki Scraper (`parseforge/liquipedia-esports-wiki-scraper`) Actor

Scrape Liquipedia esports wiki across League of Legends, Dota 2, CS:GO, Valorant, StarCraft, and Overwatch. Get tournaments, teams, players, matches, prize pools, brackets, and earnings. Export esports data to JSON, CSV, or Excel for analytics, betting models, and fan content.

- **URL**: https://apify.com/parseforge/liquipedia-esports-wiki-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎮 Liquipedia Esports Wiki Scraper

> 🚀 **Export the Liquipedia esports wiki in seconds.** Tournaments, teams, players, prize pools, brackets, and metadata across **24 game wikis**. No scraping pipeline, no captchas, no manual ETL.

> 🕒 **Last updated:** 2026-05-23 · **📊 14 fields** per record · **🎮 24 game wikis** · **🏆 Tournaments, teams, players, events** · **🌍 Global esports coverage**

The **Liquipedia Esports Wiki Scraper** taps the official Liquipedia MediaWiki API and returns clean, structured records for **tournament pages, team rosters, player profiles, prize pool tables, event categories, and any wiki page** across the Liquipedia ecosystem. The underlying wikis are community-maintained, refresh daily, and are widely cited as the source of record for competitive esports.

Coverage spans **24 game wikis** including League of Legends, Counter-Strike, Dota 2, Valorant, StarCraft Brood War, StarCraft 2, Rocket League, Overwatch, Apex Legends, Fortnite, Rainbow Six, Smash, Warcraft, Call of Duty, Halo, Age of Empires, PUBG, Free Fire, Mobile Legends, Wild Rift, Hearthstone, Magic: The Gathering, EA Sports FC, and Rocket Arena. Each wiki carries thousands of tournament, team, and player pages, all queryable in one Actor.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Esports analytics teams, tournament organizers, fan-site builders, betting researchers, streamers, journalists, scouting platforms | Tournament catalogs, prize pool tracking, team & roster sync, player profile feeds, event monitoring, fantasy esports |

---

### 📋 What the Liquipedia Scraper does

Two query modes in a single Actor:

- 📄 **Single page mode.** Pull any wiki page by title, get its parsed HTML, sections, links, categories, images, and a clean text summary.
- 🗂️ **Category mode.** List every page inside a wiki category, then enrich each with full page metadata. Categories like `Category:Tournaments`, `Category:Teams`, `Category:Players` enumerate the wiki end-to-end.

Each record returns the canonical page URL, page ID, sections outline, categories the page belongs to, outgoing links, external references, and embedded images. Toggle `includeText` off to keep records small for fast catalog runs.

> 💡 **Why it matters:** Liquipedia is the reference source for competitive esports, but parsing wiki templates and tournament brackets manually is painful. This Actor turns wiki pages into clean JSON your dashboard can ingest.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a tournament dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>game</td><td>string</td><td>"valorant"</td><td>One of 24 game wiki slugs.</td></tr>
<tr><td>pageName</td><td>string</td><td><i>none</i></td><td>Exact wiki page title. Overrides categoryFilter.</td></tr>
<tr><td>categoryFilter</td><td>string</td><td>"Category:Tournaments"</td><td>List all pages inside this category.</td></tr>
<tr><td>includeText</td><td>boolean</td><td>true</td><td>Include parsed HTML body. Disable for faster catalog runs.</td></tr>
</tbody>
</table>

**Example: 10 Valorant tournament pages.**

```json
{
    "maxItems": 10,
    "game": "valorant",
    "categoryFilter": "Category:Tournaments",
    "includeText": true
}
````

**Example: single page on Counter-Strike Major Berlin 2023.**

```json
{
    "maxItems": 1,
    "game": "counterstrike",
    "pageName": "BLAST/Major/2023/Paris"
}
```

> ⚠️ **Good to Know:** Liquipedia asks API clients to keep request volume low. This Actor automatically rate-limits between page fetches (2.5s) to stay friendly with the wiki. For very large category dumps, prefer `includeText: false` to keep records compact.

***

### 📊 Output

Each record contains **14 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `recordType` | string | `"page"` |
| 🎮 `game` | string | `"valorant"` |
| 🆔 `pageId` | integer | `12345` |
| 📄 `title` | string | `"VCT/2024/Champions"` |
| 🔗 `url` | string | `"https://liquipedia.net/valorant/VCT/2024/Champions"` |
| 📝 `summary` | string | null | First paragraph text, max 600 chars |
| 🗂️ `categories` | array | `["Tournaments", "2024 Tournaments", "S-Tier Tournaments"]` |
| 📑 `sections` | array | `[{ level, line, anchor, index }]` |
| 🔗 `links` | array | List of internal wiki links |
| 🌐 `externalLinks` | array | List of external URLs |
| 🖼️ `images` | array | List of image filenames on the page |
| ↩️ `redirects` | array | List of redirect titles |
| 📃 `html` | string | null | Parsed page HTML (if `includeText`) |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏆 Valorant: VCT 2024 Champions tournament page</strong></summary>

```json
{
    "recordType": "page",
    "game": "valorant",
    "pageId": 84211,
    "title": "VCT/2024/Champions",
    "url": "https://liquipedia.net/valorant/VCT/2024/Champions",
    "summary": "VCT 2024: Champions is the third and final international tournament of the 2024 Valorant Champions Tour, featuring 16 teams competing for a $2,250,000 prize pool in Seoul, South Korea.",
    "categories": ["Tournaments", "2024 Tournaments", "S-Tier Tournaments", "Champions Tour Tournaments"],
    "sections": [
        { "level": "2", "line": "Format", "anchor": "Format", "index": "1" },
        { "level": "2", "line": "Prize Pool", "anchor": "Prize_Pool", "index": "2" }
    ],
    "externalLinks": ["https://valorantesports.com/vct-international"],
    "images": ["VCT_Champions_2024.png"],
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🛡️ Counter-Strike: Team profile page</strong></summary>

```json
{
    "recordType": "page",
    "game": "counterstrike",
    "pageId": 1024,
    "title": "Natus Vincere",
    "url": "https://liquipedia.net/counterstrike/Natus_Vincere",
    "summary": "Natus Vincere (Latin for 'Born to Win'), commonly abbreviated as NAVI, is a Ukrainian esports organization founded in 2009.",
    "categories": ["Teams", "Active Teams", "Ukrainian Teams"],
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🎮 League of Legends: World Championship page</strong></summary>

```json
{
    "recordType": "page",
    "game": "leagueoflegends",
    "title": "2024 Season World Championship",
    "url": "https://liquipedia.net/leagueoflegends/2024_Season_World_Championship",
    "summary": "The 2024 World Championship is the conclusion of the 14th season of League of Legends competitive play.",
    "categories": ["Tournaments", "S-Tier Tournaments", "2024 Tournaments"],
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎮 | **24 game wikis.** From LoL and CS to Valorant, Dota 2, Rocket League, Hearthstone, EA Sports FC, and more. |
| 🗂️ | **Two flexible modes.** Pull a single page or enumerate an entire wiki category. |
| 🏆 | **Tournament-grade detail.** Page sections expose Format, Prize Pool, Bracket, Schedule outlines. |
| ⚡ | **Polite by default.** Auto rate-limits at 2.5s per page to stay friendly with the wiki. |
| 🌐 | **Reference source.** Liquipedia is the de facto record-of-truth for competitive esports. |
| 🔁 | **Always fresh.** Every run hits the live MediaWiki API. |
| 🚫 | **No authentication.** Public wiki data, no account needed. |

> 📊 Esports newsletters, fantasy platforms, and tournament organizers all run on Liquipedia metadata. This Actor turns that metadata into a flat, joinable dataset.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Liquipedia Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **24 wikis, all categories** | **Live per run** | game, page, category | ⚡ 2 min |
| Commercial esports data feeds | $200+/month | Top games only | Streaming | Many | 🐢 Days |
| Manual wiki scraping | Free | Per-page | Manual | None | 🐌 Weeks |
| Tournament organizer dumps | Free | Single event | Stale | None | 🕒 Variable |

Pick this Actor when you want broad esports coverage with category-level enumeration and zero auth overhead.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Liquipedia Esports Wiki Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a game, choose a category (or a specific page name), and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor enumerate the wiki for you.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏆 Esports Analytics & Scouting

- Tournament catalogs across multiple games
- Roster history and player movement tracking
- Prize pool comparisons across regions
- Team & event ML feature engineering

</td>
<td width="50%" valign="top">

#### 🎮 Fan Sites & Fantasy

- Auto-sync upcoming events into fan calendars
- Player profile cards for fantasy lineups
- Region-by-region tournament filtering
- Team logo and metadata sourcing

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Esports Media

- Auto-publish event summaries with structured metadata
- Multi-game coverage from one pipeline
- Historic tournament retrospectives
- Game-by-game audience research

</td>
<td width="50%" valign="top">

#### 📊 Betting Research & Modeling

- Backtest models against historic tournaments
- Track prize pool inflation per game
- Roster-change correlation studies
- Cross-tournament feature engineering

</td>
</tr>
</table>

***

### 🔌 Automating Liquipedia Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Refresh tournament catalogs every Monday or pull rosters monthly.

***

### 🌟 Beyond business use cases

Structured esports data feeds research, classrooms, fan creativity, and personal projects.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Studies on esports growth and prize-pool inflation
- Sports management coursework on competitive gaming
- Reproducible datasets for sociology of gaming
- Open-data exercises on digital sports

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal tournament calendars and dashboards
- Fantasy esports trackers in Notion or Sheets
- Streamer prep notes for casting
- Fan blog data tables and infographics

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Collegiate esports clubs with tournament feeds
- Community open-data archives of competitive gaming
- Cultural studies of regional esports scenes
- Investigative journalism on tournament organizers

</td>
<td width="50%">

#### 🧪 Experimentation

- Train tournament-winner prediction ML models
- Prototype an agent that drafts esports newsletters
- Build a "who plays tomorrow?" Discord bot
- Test data warehouse loaders on wiki schemas

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Liquipedia%20Esports%20Wiki%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Liquipedia%20Esports%20Wiki%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Liquipedia%20Esports%20Wiki%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Liquipedia%20Esports%20Wiki%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a game wiki, then either point at a specific page or enumerate a category. The Actor returns one record per page with parsed metadata, sections, links, and optional HTML body.

#### 🎮 Which games are covered?

24 game wikis: League of Legends, Counter-Strike, Dota 2, StarCraft (Brood War + 2), Valorant, Rocket League, Overwatch, Apex Legends, Fortnite, Rainbow Six, Smash, Warcraft, Call of Duty, Halo, Age of Empires, PUBG, Free Fire, Mobile Legends, Wild Rift, Hearthstone, Magic: The Gathering, EA Sports FC, Rocket Arena.

#### 📏 How accurate is the data?

Liquipedia is community-edited and updated continuously. Tournament pages typically reflect the live state within hours.

#### 🔁 How often is the dataset refreshed?

Every run pulls the latest data. For active tournaments, schedule daily refreshes.

#### ⚙️ Why is it rate-limited?

Liquipedia asks scrapers to stay polite. The Actor automatically waits 2.5s between page fetches. This keeps the wiki community happy and avoids HTTP 429s.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval.

#### ⚖️ Is this data legal to use?

Liquipedia content is licensed under CC-BY-SA 3.0. Review the license terms for your use case before redistributing.

#### 💼 Can I use this data commercially?

Yes for attribution-compliant uses. Liquipedia's license requires credit and share-alike. Tournament logos and team branding belong to their respective owners.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan handles small runs (10 pages). Paid plans lift the cap and unlock scheduling.

#### 🔁 What happens if a run fails?

Apify retries transient errors automatically. Failed runs preserve partial datasets so no progress is lost.

#### 🛬 What if I need bracket / match-level data?

The Actor returns page sections and HTML, which contain bracket markup. Parse the HTML for structured brackets or request a companion bracket scraper via the contact form below.

#### 🆘 What if I need help?

Reach our support team through the Apify platform or the Tally form linked below.

***

### 🔌 Integrate with any app

Liquipedia Esports Wiki Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get tournament alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe wiki data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh tournament data into your product backend, or alert your Discord on a new event listing.

***

### 🔗 Recommended Actors

- [**⚽ OpenLigaDB Football Matches Scraper**](https://apify.com/parseforge/openligadb-football-matches-scraper) - Bundesliga, DFB-Pokal, UEFA matches + goals
- [**🏆 Football-Data.org Competitions Scraper**](https://apify.com/parseforge/football-data-org-competitions-scraper) - Premier League, La Liga, Serie A standings
- [**📺 IMDb Scraper**](https://apify.com/parseforge/imdb-scraper) - Movie, TV, and entertainment metadata
- [**🎬 TMDb Scraper**](https://apify.com/parseforge/tmdb-scraper) - Movie + TV metadata, ratings, posters
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode venue addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Liquipedia, Wikimedia, Riot Games, Valve, EA, Activision Blizzard, or any tournament organizer. All trademarks mentioned are the property of their respective owners. Liquipedia content is licensed under CC-BY-SA 3.0. Only publicly available wiki data is collected.

# Actor input Schema

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

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

## `game` (type: `string`):

Which Liquipedia game wiki to query.

## `pageName` (type: `string`):

Exact wiki page title (use underscores or spaces). Example for Valorant: 'VCT/2024'. If both pageName and categoryFilter are provided, pageName takes priority.

## `categoryFilter` (type: `string`):

List all pages inside this category. Example: 'Category:Tournaments' or 'Category:Teams'. Combine with a game wiki.

## `includeText` (type: `boolean`):

Include the parsed HTML body of each page. Large pages produce big records; disable for faster catalog runs.

## Actor input object example

```json
{
  "maxItems": 10,
  "game": "valorant",
  "categoryFilter": "Category:Tournaments",
  "includeText": true
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "game": "valorant",
    "categoryFilter": "Category:Tournaments"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/liquipedia-esports-wiki-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 = {
    "maxItems": 10,
    "game": "valorant",
    "categoryFilter": "Category:Tournaments",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/liquipedia-esports-wiki-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 '{
  "maxItems": 10,
  "game": "valorant",
  "categoryFilter": "Category:Tournaments"
}' |
apify call parseforge/liquipedia-esports-wiki-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Liquipedia Esports Wiki Scraper",
        "description": "Scrape Liquipedia esports wiki across League of Legends, Dota 2, CS:GO, Valorant, StarCraft, and Overwatch. Get tournaments, teams, players, matches, prize pools, brackets, and earnings. Export esports data to JSON, CSV, or Excel for analytics, betting models, and fan content.",
        "version": "1.0",
        "x-build-id": "rUxRmbARwKoYRmh8c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~liquipedia-esports-wiki-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-liquipedia-esports-wiki-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~liquipedia-esports-wiki-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-liquipedia-esports-wiki-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~liquipedia-esports-wiki-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-liquipedia-esports-wiki-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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "game": {
                        "title": "Game Wiki",
                        "enum": [
                            "leagueoflegends",
                            "counterstrike",
                            "dota2",
                            "starcraft",
                            "starcraft2",
                            "valorant",
                            "rocketleague",
                            "overwatch",
                            "apexlegends",
                            "fortnite",
                            "rainbowsix",
                            "smash",
                            "warcraft",
                            "callofduty",
                            "halo",
                            "ageofempires",
                            "pubg",
                            "freefire",
                            "mobilelegends",
                            "wildrift",
                            "hearthstone",
                            "magic",
                            "easportsfc",
                            "rocketarena"
                        ],
                        "type": "string",
                        "description": "Which Liquipedia game wiki to query."
                    },
                    "pageName": {
                        "title": "Page Name",
                        "type": "string",
                        "description": "Exact wiki page title (use underscores or spaces). Example for Valorant: 'VCT/2024'. If both pageName and categoryFilter are provided, pageName takes priority."
                    },
                    "categoryFilter": {
                        "title": "Category Filter",
                        "type": "string",
                        "description": "List all pages inside this category. Example: 'Category:Tournaments' or 'Category:Teams'. Combine with a game wiki."
                    },
                    "includeText": {
                        "title": "Include Parsed HTML",
                        "type": "boolean",
                        "description": "Include the parsed HTML body of each page. Large pages produce big records; disable for faster catalog runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
