# League of Legends Champion & Item Stats Extractor (`vexaloom-labs/league-of-legends-champion-and-item-stats`) Actor

Get every League of Legends champion's base stats, role tags, and difficulty rating, or every in-game item's gold cost and tags, for the current patch or a specific game version.

- **URL**: https://apify.com/vexaloom-labs/league-of-legends-champion-and-item-stats.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Automation, Developer tools, Other
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## League of Legends Champion & Item Stats Extractor

Riot Games publishes League of Legends' static game data through Data Dragon, its public CDN. This actor turns those patch files into clean datasets: champion base stats and role tags, full champion lore with abilities and skins, item prices and build paths, runes, summoner spells, profile icons, maps, and the patch history itself — in 25 languages and for any patch you pin. No Riot API key, login, cookie, or proxy is needed.

### What this actor does

- **Champions** — every champion with level-1 base stats, per-level growth, role tags, resource type, Riot's difficulty ratings, and a portrait URL.
- **Champion details** — lore, play/against tips, the passive plus Q/W/E/R ability data, and every skin with splash and loading-screen art URLs.
- **Items** — shop price (total/base/sell), tags, stat modifiers, build-from/build-into paths, stack counts, champion restrictions, and which maps stock the item.
- **Summoner spells** — cooldowns, costs, ranges, available game modes, and the level unlock.
- **Runes** — every reforged rune with its tree, slot, keystone flag, and plain-language effect text.
- **Profile icons and maps** — IDs and direct image URLs.
- **Patch versions** — the published release list, newest first, with major/minor/patch parts.
- **Filters and paging** — role, item tag, gold range, purchasable-only, map, rune tree, text search, `offset`, and `maxItems`.
- **Any supported language** — a `locale` dropdown covering every Data Dragon locale that publishes data.
- **Omit-empty output** — a field the CDN does not publish for a record is left out, never sent as `null` or a placeholder.

### Output fields

#### `mode: "champions"`

| Field | Meaning |
|---|---|
| `championId`, `championKey` | Data Dragon id (e.g. `Ahri`) and numeric Riot key (e.g. `103`) |
| `championName`, `title` | Display name and epithet |
| `blurb` | Short lore summary |
| `tags` | Role tags: Assassin, Fighter, Mage, Marksman, Support, Tank |
| `partype` | Resource type (Mana, Energy, Blood Well, …) |
| `hp`, `hpPerLevel` | Base health and growth per level |
| `mana`, `manaPerLevel` | Base resource and growth per level |
| `moveSpeed`, `attackRange` | Base movement speed and attack range |
| `armor`, `armorPerLevel` | Base armor and growth |
| `spellBlock`, `spellBlockPerLevel` | Base magic resist and growth |
| `hpRegen`, `hpRegenPerLevel` | Health regen and growth |
| `manaRegen`, `manaRegenPerLevel` | Resource regen and growth |
| `crit`, `critPerLevel` | Base crit chance and growth |
| `attackDamage`, `attackDamagePerLevel` | Base attack damage and growth |
| `attackSpeed`, `attackSpeedPerLevel` | Base attack speed and growth |
| `attackSpeedOffset` | Legacy attack-speed offset, only on patches that publish it |
| `difficulty`, `attack`, `defense`, `magic` | Riot's 1–10 ratings |
| `imageUrl` | Square champion portrait |
| `version`, `locale` | Patch and language this record came from |

#### `mode: "championDetails"`

Includes every champion field above, plus:

| Field | Meaning |
|---|---|
| `lore` | Full champion biography |
| `allyTips`, `enemyTips` | Play tips and counter tips |
| `passive` | `{passiveName, description, imageUrl}` |
| `spells` | Q/W/E/R objects with `spellId`, `spellName`, `slot`, `description`, `tooltip`, `maxRank`, `cooldown`, `cooldownBurn`, `cost`, `costBurn`, `costType`, `range`, `rangeBurn`, `imageUrl` |
| `skins` | Every skin with `skinId`, `skinNum`, `skinName`, `chromas`, `parentSkin`, `splashUrl`, `loadingUrl` |

#### `mode: "items"`

| Field | Meaning |
|---|---|
| `itemId`, `itemName` | Item id and name |
| `description` | Plain-text effect summary |
| `totalGold`, `baseGold`, `sellGold` | Purchase and sell values |
| `purchasable` | Whether a shop sells it |
| `tags` | Item tags (Damage, SpellDamage, Boots, …) |
| `depth`, `stacks`, `consumable` | Recipe depth, stack count, consumable flag when published |
| `requiredChampion`, `requiredAlly` | Champion or ally required to buy it |
| `buildsFrom`, `buildsInto` | Component ids and upgrade ids |
| `statMods` | Raw stat modifiers, e.g. `{"FlatHPPoolMod": 150}` |
| `availableMaps` | `[{mapId, mapName}]` for every map that stocks it |
| `imageUrl` | Item icon |

#### `mode: "summonerSpells"`

`spellId`, `spellKey`, `spellName`, `description`, `tooltip`, `maxRank`, `cooldown`, `cooldownBurn`, `cost`, `costBurn`, `costType`, `range`, `rangeBurn`, `modes`, `summonerLevel`, `imageUrl`.

#### `mode: "runes"`

`runeId`, `runeKey`, `runeName`, `treeId`, `treeKey`, `treeName`, `slotIndex`, `isKeystone`, `shortDescription`, `longDescription`, `iconUrl`.

#### `mode: "profileIcons"`

`iconId`, `imageUrl`.

#### `mode: "maps"`

`mapId`, `mapName` (when published), `imageUrl`.

#### `mode: "versions"`

`version`, `major`, `minor`, `patch`, `isLatest`.

Every record also carries `recordType` and `scrapedAt` (UTC ISO timestamp).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `champions` | Dataset to export: `champions`, `championDetails`, `items`, `summonerSpells`, `runes`, `profileIcons`, `maps`, `versions`. |
| `tag` | string | – (all roles) | Champion role filter; applies to `champions` and `championDetails`. |
| `search` | string | – (no filter) | Case-insensitive match on names and ids in every mode. |
| `championIds` | array | – (all) | `championDetails` only: ids, names, or champion.json URLs; comma-separated strings also accepted. |
| `itemTag` | string | – (all tags) | Item tag filter for `items`. |
| `minGold` | integer | – (no minimum) | Minimum total gold for `items`. |
| `maxGold` | integer | – (no maximum) | Maximum total gold for `items`; an inverted range returns nothing. |
| `purchasableOnly` | boolean | `false` | Skip items a shop will not sell. |
| `mapId` | string | – (any map) | `11`, `12`, `22`, `30`, or `453`; limits `items` to that map. |
| `runeTree` | string | – (all trees) | Domination, Inspiration, Precision, Resolve, or Sorcery. |
| `locale` | string | `en_US` | Language for names and text. |
| `version` | string | – (latest) | Data Dragon patch such as `16.22.1`; unpublished versions fall back to the latest. |
| `maxItems` | integer | `50` | Records to return after filters and offset (1–10,000). |
| `offset` | integer | `0` | Records to skip; combine with `maxItems` to page. |

Only `mode` is required. The current production presets (`mode`, `tag`, `version`, `maxItems`) and the older singular modes `champion` and `item` are still accepted unchanged.

### Examples

All champions with their stats:

```json
{ "mode": "champions", "maxItems": 200 }
```

Support champions in Korean:

```json
{ "mode": "champions", "tag": "Support", "locale": "ko_KR" }
```

Full details and skins for two champions:

```json
{ "mode": "championDetails", "championIds": ["Ahri", "Jinx"] }
```

Boots between 300 and 1,200 gold on Summoner's Rift:

```json
{
  "mode": "items",
  "itemTag": "Boots",
  "minGold": 300,
  "maxGold": 1200,
  "mapId": "11",
  "purchasableOnly": true
}
```

Second page of 100 runes, newest patch:

```json
{ "mode": "runes", "maxItems": 100, "offset": 100 }
```

### Use cases

- **Build calculators and companion apps** — seed a database with current champion stats, item prices, and upgrade paths.
- **Wiki and content sites** — keep champion lore, abilities, skins, and localized names in sync with each patch.
- **Balance research** — pin two patches and diff the same champion or item records to see what changed.
- **Draft and coaching tools** — filter champions by role and feed base stats or ability ranges into matchup models.
- **Game-data pipelines** — join Riot's numeric ids from match data to names and icons using `championKey`, `itemId`, `runeId`, and `spellKey`.

### FAQ

**Do I need a Riot API key?**
No. Data Dragon is a public static-data CDN; no key, login, cookie, or proxy is required.

**Which patch is used?**
The latest published Data Dragon release unless you set `version`. Each record stores the version it came from, so datasets stay reproducible.

**Can I compare two patches?**
Run the actor once per version and diff the datasets on `championId` or `itemId`.

**How many languages are supported?**
25\. Vietnamese appears in Riot's documentation but Data Dragon does not publish its data files, so it is not offered.

**Why are some items missing a name or description?**
Data Dragon includes placeholder item ids with no name, which are skipped; when an item has no plain-text summary the actor derives one from its rich-text description.

**Why does `attackSpeed` differ from an old export?**
Older builds copied Riot's attack-speed *offset*, which is a small negative number. This version maps `attackSpeed` to the real base attack speed and keeps the offset in `attackSpeedOffset` when the patch publishes it.

**Is this affiliated with Riot Games?**
No. It reads Riot's public Data Dragon CDN and is not endorsed by or affiliated with Riot Games.

### Limitations

- Static game data only: no live matches, player ranks, or win rates (those require the Riot API and an API key).
- Data Dragon is updated manually after a patch, so the newest champion or item can lag the live game by a short time.
- Some items and one map have no published name; those records carry only the fields the CDN provides.
- Only release versions are listed in `versions` mode; internal patch-tool builds are excluded.
- Historical patches are available only as far back as Data Dragon's published version list.

# Actor input Schema

## `mode` (type: `string`):

Which Data Dragon dataset to export.

## `tag` (type: `string`):

Only champions with this role (mode=champions or championDetails).

## `search` (type: `string`):

Case-insensitive match on the record name or id. Works in every mode.

## `championIds` (type: `array`):

Only for championDetails mode. Data Dragon IDs, champion names or champion.json URLs; accepts a comma-separated string. Leave empty for all champions.

## `itemTag` (type: `string`):

Only items with this tag (mode=items).

## `minGold` (type: `integer`):

Only items costing at least this much (mode=items).

## `maxGold` (type: `integer`):

Only items costing at most this much (mode=items). An inverted range returns no records.

## `purchasableOnly` (type: `boolean`):

Skip items that cannot be bought in a shop (mode=items).

## `mapId` (type: `string`):

Only items available on this map (mode=items).

## `runeTree` (type: `string`):

Only runes from this tree (mode=runes).

## `locale` (type: `string`):

Language of names and descriptions. Every supported Data Dragon locale except Vietnamese is available.

## `version` (type: `string`):

Data Dragon patch such as 16.22.1. Leave blank for the latest patch; an unpublished version falls back to the latest with a warning.

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

Maximum records to return after filters and offset.

## `offset` (type: `integer`):

Skip this many matching records, for paging through large datasets.

## Actor input object example

```json
{
  "mode": "champions",
  "tag": "",
  "itemTag": "",
  "purchasableOnly": false,
  "mapId": "",
  "runeTree": "",
  "locale": "en_US",
  "maxItems": 3,
  "offset": 0
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped champion, item, rune, summoner-spell, profile-icon, map or patch-version records.

# 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 = {
    "mode": "champions",
    "purchasableOnly": false,
    "locale": "en_US",
    "maxItems": 3,
    "offset": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/league-of-legends-champion-and-item-stats").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 = {
    "mode": "champions",
    "purchasableOnly": False,
    "locale": "en_US",
    "maxItems": 3,
    "offset": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/league-of-legends-champion-and-item-stats").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 '{
  "mode": "champions",
  "purchasableOnly": false,
  "locale": "en_US",
  "maxItems": 3,
  "offset": 0
}' |
apify call vexaloom-labs/league-of-legends-champion-and-item-stats --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/league-of-legends-champion-and-item-stats"
        }
    }
}
```

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/grTnEnEddhLr57JXy/builds/JHX4a4EQ5xaBeJ8WD/openapi.json
