# Liquipedia Esports Events, Matches, Teams & Players Scraper (`automation-lab/liquipedia-esports-wiki-scraper`) Actor

Export structured Liquipedia esports events, matches, teams, players, rosters, prizes, scores, and source revision records.

- **URL**: https://apify.com/automation-lab/liquipedia-esports-wiki-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 1 total users, 0 monthly users, 97.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.56 / 1,000 item extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Events, Matches, Teams & Players Scraper

Export structured Liquipedia esports events matches teams and players records for tournament research, roster analysis, result tracking, and revision-aware data pipelines.

The Actor uses Liquipedia's official MediaWiki API. It turns wiki templates and rendered bracket data into typed event, match, team, player, roster, prize, page, and revision rows.

Supply exact Liquipedia URLs or titles, search a game wiki, browse one category, or include tournament subpages. Every result retains its source URL, source revision, timestamp, and CC BY-SA attribution.

### What can this Liquipedia scraper do?

- Extract tournament metadata from event infoboxes.
- Export bracket matches with teams, scores, dates, and status.
- Normalize team and player profile infoboxes.
- Turn roster templates into one row per player entry.
- Capture placements and prize fields when the page exposes them.
- Record the exact page and revision behind every extraction.
- Search a selected game wiki through MediaWiki search.
- Discover exact category members.
- Follow tournament subpages within a bounded page limit.
- Optionally include raw wikitext for archival or custom parsing.

The default dataset is ready for JSON, CSV, Excel, API, webhook, and scheduled-run workflows.

### Who is it for?

**Esports analysts** can refresh tournament schedules, brackets, results, and roster datasets.

**Team and player researchers** can compare current profiles and source revisions across scheduled runs.

**Data engineers** can feed attributed wiki records into warehouses, dashboards, notebooks, and monitoring jobs.

**Publishers and community teams** can create source-linked event and matchup tables without copying rendered pages by hand.

**Scouting and competitive-intelligence teams** can export structured participant and roster data for further analysis.

### Why use this Actor?

Liquipedia pages mix MediaWiki templates, transclusion, and LPDB-backed rendered brackets. A plain HTML selector or generic page downloader does not produce stable typed records.

This Actor:

1. Uses the documented API instead of automating generated HTML pages.
2. Respects the published two-second API gate and 30-second parse gate.
3. Batches revision requests where the API permits it.
4. Extracts typed records instead of returning only a large HTML body.
5. Keeps stable page IDs, revision IDs, canonical URLs, and attribution.
6. Fails clearly on malformed inputs and upstream API errors.

### Supported game wikis

The input selector includes major Liquipedia wikis such as:

- Dota 2
- Counter-Strike
- Valorant
- League of Legends
- Rocket League
- Rainbow Six
- Overwatch
- StarCraft and StarCraft II
- Apex Legends
- PUBG
- Mobile Legends
- Warcraft and World of Warcraft
- and the other game values listed in the input schema

A run processes one game wiki so that titles, search results, and categories remain unambiguous.

### What data is extracted?

| Record type | Typical fields |
| --- | --- |
| `event` | name, dates, status, series, location, prize pool, template data |
| `match` | opponents, scores, scheduled time, completion status, best-of value |
| `team` | name, region, location, website, social handles, source template data |
| `player` | handle, real name, nationality, role, team, profile fields |
| `roster` | player, team context, role/position, join date, leave date |
| `prize` | placement, prize, currency, participant data |
| `revision` | page ID, revision ID, timestamp, editor/comment metadata, categories |
| `page` | source identity for pages without a recognized entity template |

Fields that do not apply to a record type are omitted. The complete normalized template content remains available in `data`.

### Getting started

1. Open the Actor in Apify Console.
2. Select a `wiki`, for example `dota2`.
3. Choose exactly one route:
   - `urls` or `pageTitles`;
   - `searchQuery`; or
   - `category`.
4. Set `maxPages` and `maxItems` for the desired scope.
5. Enable `includeSubpages` for a tournament overview when stage pages are needed.
6. Click **Start**.
7. Open the default dataset and select the **Esports records** view.
8. Export JSON, CSV, XML, RSS, or Excel, or retrieve results through the API.

A good first run is:

```json
{
  "wiki": "dota2",
  "urls": [
    "https://liquipedia.net/dota2/The_International/2024/Main_Event"
  ],
  "maxPages": 1,
  "maxItems": 100
}
```

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `wiki` | string | `dota2` | Selected Liquipedia game wiki. |
| `urls` | string\[] | Main Event example | Exact public wiki page URLs. |
| `pageTitles` | string\[] | — | Exact titles such as `Team Liquid` or `Nisha`. |
| `searchQuery` | string | — | MediaWiki full-text search query. |
| `category` | string | — | Exact category name, with or without `Category:`. |
| `includeSubpages` | boolean | `false` | Include matching title subpages up to `maxPages`. |
| `includeRawWikitext` | boolean | `false` | Attach source wikitext to revision rows. |
| `maxPages` | integer | `10` | Maximum source pages, from 1 to 50. |
| `maxItems` | integer | `20` | Maximum saved records, from 1 to 5,000. |

Use only one discovery route per run. URLs and exact titles may be combined because both identify explicit pages.

### Output example

This abbreviated record comes from a real local Main Event run:

```json
{
  "recordId": "dota2:145966:2419892:rendered-match:1",
  "type": "match",
  "wiki": "dota2",
  "pageTitle": "The International/2024/Main Event",
  "name": "Xtreme Gaming vs Team Liquid",
  "date": "2024-09-08T08:00:00.000Z",
  "status": "finished",
  "team1": "Xtreme Gaming",
  "team2": "Team Liquid",
  "score1": "0",
  "score2": "2",
  "revisionId": 2419892,
  "source": "Liquipedia",
  "sourceUrl": "https://liquipedia.net/dota2/The_International/2024/Main_Event",
  "license": "CC BY-SA 3.0"
}
```

Record IDs include wiki, page, revision, type, and sequence. They are useful for revision-aware imports and deduplication.

### How much does it cost to export Liquipedia esports records?

The Actor uses pay-per-event pricing:

- **Start:** $0.005 once per run.
- **Item:** $0.0076 per saved record at the BRONZE tier.

At that tier, 10 records cost about **$0.081**, 100 records about **$0.765**, and 1,000 records about **$7.605** including the start event.

Apify applies account-tier prices automatically. The Console shows the applicable price before a run. Only records saved to the dataset incur the item event; rejected, duplicate, missing, or failed pages are not item events.

Rendered match pages can run longer because Liquipedia requires a 30-second interval between expensive parse requests. This affects runtime, not the number of item events.

### Tournament and match workflow

Use an exact stage URL when match rows are the priority:

```json
{
  "wiki": "dota2",
  "urls": ["https://liquipedia.net/dota2/The_International/2024/Main_Event"],
  "maxPages": 1,
  "maxItems": 100
}
```

Use the overview URL with `includeSubpages` when you need several linked stage pages:

```json
{
  "wiki": "dota2",
  "pageTitles": ["The International/2024"],
  "includeSubpages": true,
  "maxPages": 8,
  "maxItems": 500
}
```

Subpages are bounded by `maxPages`. Set the page limit deliberately because each match-bearing page must respect Liquipedia's parse interval.

### Team and roster workflow

Exact titles are efficient for recurring roster jobs:

```json
{
  "wiki": "dota2",
  "pageTitles": ["Nisha", "Team Liquid"],
  "maxPages": 2,
  "maxItems": 200
}
```

Schedule the same input daily or weekly. Compare `revisionId` with the prior dataset before processing deeper fields.

Roster templates may contain current and historical members. Use the source template fields, join/leave dates, and revision ID when deciding which entries belong in a downstream current-roster view.

### Search and category workflow

Search finds ranked page titles before extraction:

```json
{
  "wiki": "dota2",
  "searchQuery": "The International 2024",
  "maxPages": 5,
  "maxItems": 100
}
```

Category mode uses an exact MediaWiki category:

```json
{
  "wiki": "dota2",
  "category": "Players",
  "maxPages": 20,
  "maxItems": 500
}
```

Category membership and page content change over time. Preserve revision fields when building snapshots.

### Scheduling and monitoring changes

Create an Apify Schedule with a stable explicit-title or URL input.

A practical change pipeline is:

1. Run the Actor on a schedule.
2. Read revision records first.
3. Compare `pageId` and `revisionId` with the previous successful run.
4. Process entity rows only for changed pages.
5. Send changed rows to a webhook, database, or automation platform.

The Actor exports snapshots. It does not retain prior runs or send alerts by itself.

### API usage with cURL

Start a run and wait for its dataset:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~liquipedia-esports-wiki-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"wiki":"dota2","pageTitles":["Nisha"],"maxPages":1,"maxItems":20}'
```

For larger jobs, start asynchronously and poll the run status rather than holding one HTTP connection.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/liquipedia-esports-wiki-scraper').call({
  wiki: 'dota2',
  urls: ['https://liquipedia.net/dota2/The_International/2024/Main_Event'],
  maxPages: 1,
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((item) => item.type === 'match'));
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/liquipedia-esports-wiki-scraper').call(run_input={
    'wiki': 'dota2',
    'pageTitles': ['Nisha', 'Team Liquid'],
    'maxPages': 2,
    'maxItems': 200,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print([item for item in items if item['type'] in ('player', 'team', 'roster')])
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/liquipedia-esports-wiki-scraper"
```

Claude Desktop, Cursor, and VS Code can use this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/liquipedia-esports-wiki-scraper"
    }
  }
}
```

Example prompts:

- “Export The International 2024 Main Event match scores from Liquipedia.”
- “Get the Liquipedia Dota 2 profiles and roster records for Nisha and Team Liquid.”
- “Search the Valorant wiki for VCT 2026 event pages and return revision IDs.”

### Integrations

Connect the dataset to:

- Google Sheets or Microsoft Excel for analyst review;
- webhooks for revision-change processing;
- Make, Zapier, or n8n for scheduled workflows;
- BigQuery, Snowflake, PostgreSQL, or object storage;
- Python/R notebooks and BI tools;
- Apify dataset exports and REST API clients.

Use `type` to route heterogeneous records into separate destination tables.

### Legality and responsible use

Liquipedia content is licensed under **CC BY-SA 3.0**. Keep attribution and comply with share-alike requirements when redistributing adapted content. Every row includes Liquipedia attribution and a source URL.

The Actor follows Liquipedia's MediaWiki API terms: custom identification, gzip transport, at most one API request per two seconds, and at most one parse request per 30 seconds. It does not automate generated HTML pages.

You are responsible for your downstream use, publication, retention, and compliance. Do not remove attribution or use the data to misrepresent Liquipedia, teams, players, or event organizers.

Source templates and page structures can change. Validate critical decisions against the linked source page.

### Troubleshooting

#### Why did my run fail before requesting Liquipedia?

The input must contain one route only. Remove extra `searchQuery` or `category` values when using URLs/titles. Confirm that every URL belongs to the selected wiki.

#### Why did a valid search return no rows?

Search can naturally return no matching page. Try a shorter exact event/player phrase, verify the game wiki, and increase `maxPages` only when relevant results exist.

#### Why is a match-page run slower than a profile run?

Rendered brackets depend on Liquipedia's expensive parse operation. The Actor enforces the required 30-second interval. Team/player revision queries are batchable and normally faster.

#### Why are some optional fields absent?

Liquipedia templates differ by game, era, and entity type. The Actor omits unavailable normalized fields and preserves recognized template values in `data`.

#### Can I use raw wikitext?

Enable `includeRawWikitext`. It is attached only to revision records and can make datasets much larger.

#### Does the Actor bypass blocks with proxies?

No. The documented direct API works and generated-page automation is prohibited. The Actor does not expose an automatic residential or browser fallback.

### FAQ

#### Does it support multiple game wikis in one run?

No. Run one wiki at a time so discovery and titles remain deterministic. Multiple runs can execute concurrently if they still respect each source's API usage.

#### Are results live scores?

Results reflect the current source revision when fetched. The Actor is not a live push feed and does not promise sub-minute updates.

#### Does it download images or media?

No. It may preserve source template image names or URLs as text, but it does not download media assets.

#### Are revision rows charged separately?

All saved rows use the same `item` event. There is no separate revision, match, roster, or prize event.

#### Can I export only matches?

Use an exact stage/main-event URL and filter the default dataset by `type=match` downstream. All emitted source revision context remains in the same run dataset.

### Related automation-lab Actors

For broader sports workflows, explore other public `automation-lab` Actors in the Apify Store. Choose a source-specific Actor when you need official schedules or statistics outside Liquipedia, and combine datasets by source URL and event identity in your pipeline.

This Actor intentionally focuses on Liquipedia's public esports wiki data rather than claiming unrelated sports feeds or private APIs.

# Actor input Schema

## `wiki` (type: `string`):

Liquipedia wiki subdomain/path, such as dota2, counterstrike, or valorant.

## `urls` (type: `array`):

Tournament, stage, team, or player page URLs from the selected game wiki. Use this or one discovery field below.

## `pageTitles` (type: `array`):

Exact Liquipedia titles as an alternative to URLs, for example Team Liquid or Nisha.

## `searchQuery` (type: `string`):

Find wiki pages with Liquipedia's official MediaWiki search API. Leave URLs, titles, and category empty.

## `category` (type: `string`):

Discover pages in one exact MediaWiki category, such as Players or Teams.

## `includeSubpages` (type: `boolean`):

For supplied pages, also fetch matching subpages such as Group Stage and Main Event up to the page limit.

## `includeRawWikitext` (type: `boolean`):

Attach source wikitext to revision records. Disabled by default to keep datasets compact.

## `maxPages` (type: `integer`):

Maximum wiki pages to fetch per run.

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

Maximum normalized event, match, team, player, roster, prize, page, and revision records to save.

## Actor input object example

```json
{
  "wiki": "dota2",
  "urls": [
    "https://liquipedia.net/dota2/The_International/2024/Main_Event"
  ],
  "includeSubpages": false,
  "includeRawWikitext": false,
  "maxPages": 10,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

API link to event, match, team, player, roster, prize, page, and revision records in the overview view.

# 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 = {
    "wiki": "dota2",
    "urls": [
        "https://liquipedia.net/dota2/The_International/2024/Main_Event"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "wiki": "dota2",
    "urls": ["https://liquipedia.net/dota2/The_International/2024/Main_Event"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/liquipedia-esports-wiki-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "wiki": "dota2",
  "urls": [
    "https://liquipedia.net/dota2/The_International/2024/Main_Event"
  ],
  "maxItems": 20
}' |
apify call automation-lab/liquipedia-esports-wiki-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/liquipedia-esports-wiki-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mlsAgQrg0rsaBHvu7/builds/DVn7ma5tCQ86JWsOK/openapi.json