Mobalytics APImobalytics.gg ↗
Access League of Legends tier list rankings, champion builds (runes, items, skill order), and matchup stats from Mobalytics via a simple REST API.
What is the Mobalytics API?
The Mobalytics API provides 3 endpoints covering League of Legends meta data: current tier list rankings by role and skill level, full champion builds including runes, items, and skill order, and per-champion statistics with counter matchups. The get_tier_list endpoint returns all champions grouped by role and tier (S through D), optionally filtered to a single role or skill level bracket.
curl -X GET 'https://api.parse.bot/scraper/e7dd7967-737e-472d-90c0-f106c9882b4e/get_tier_list?role=top&skill_level=low-elo' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace mobalytics-gg-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.mobalytics_lol_tier_list_builds_api import (
Mobalytics, Role, SkillLevel, StatsSkillLevel
)
client = Mobalytics()
# Get mid lane tier list for low elo
tier_list = client.tierlists.get(role=Role.MID, skill_level=SkillLevel.LOW_ELO)
print(tier_list.skill_level, tier_list.role_filter)
# Navigate from tier list to champion builds
for role_name, tiers in tier_list.tier_list.items():
for entry in tiers.get("S", []):
print(entry.name, entry.tier, entry.champion_types)
# Use constructible Champion to get build and stats
garen = client.champion("garen")
build_data = garen.build(role=Role.TOP)
print(build_data.patch, build_data.tier)
print(build_data.stats.win_rate, build_data.stats.pick_rate, build_data.stats.ban_rate)
print(build_data.build.items.core_items, build_data.build.runes.primary_style)
# Get champion stats with counters
stats = garen.stats(skill_level=StatsSkillLevel.LOW)
print(stats.champion_id, stats.champion_slug)
for role_stats in stats.roles:
print(role_stats.role, role_stats.win_rate, role_stats.tier)
for counter in role_stats.counters:
print(counter.champion_slug, counter.win_rate, counter.wins)
Get the current LoL meta tier list showing champion rankings (S/A/B/C/D tiers) for each role. Returns all champions grouped by role and tier, including their champion types. Can be filtered by role and skill level. Each role contains a mapping of tier labels to arrays of champion entries. The full tier list is returned in a single response.
| Param | Type | Description |
|---|---|---|
| role | string | Filter by role. Accepts exactly one of: top, jungle, mid, adc, support. Omitting returns all roles. |
| skill_level | string | Skill level tier list. Accepts exactly one of: low-elo, high-elo. |
{
"type": "object",
"fields": {
"tier_list": "object mapping role names (TOP, JUNGLE, MID, ADC, SUPPORT) to tier groupings (S, A, B, C, D), each tier containing an array of champion objects with slug, name, champion_types, tier, and tags",
"role_filter": "string or null indicating the applied role filter",
"skill_level": "string indicating the skill level used"
},
"sample": {
"data": {
"tier_list": {
"MID": {
"A": [
{
"name": "Hwei",
"slug": "hwei",
"tags": null,
"tier": "A",
"champion_types": [
"Mage"
]
}
],
"S": [
{
"name": "Fizz",
"slug": "fizz",
"tags": null,
"tier": "S",
"champion_types": [
"Assassin"
]
}
]
}
},
"role_filter": "MID",
"skill_level": "low-elo"
},
"status": "success"
}
}About the Mobalytics API
Tier List Data
The get_tier_list endpoint returns the current LoL meta tier list as an object mapping role names to tier groupings. Each tier contains an array of champion objects. You can pass a role parameter (one of top, jungle, mid, adc, support) to narrow results, and a skill_level parameter (low-elo or high-elo) to get a tier list calibrated to a specific player bracket. The response always includes the applied role_filter and skill_level so you can confirm what context the rankings reflect.
Champion Builds
The get_champion_build endpoint accepts a champion_slug (e.g. leesin, twistedfate) and an optional role. It returns a build object containing skill_order, summoner_spells, runes, and items, sourced from Emerald+ ranked games on the current patch. The response also includes the champion's tier, patch string, and a stats object with win_rate, pick_rate, and ban_rate as percentages — giving enough context to evaluate whether a build is from a statistically significant sample.
Champion Stats and Counters
The get_champion_stats endpoint returns an array of roles objects for every role a champion is played in, each containing tier, win rate, pick rate, ban rate, and a list of top counter champions. The skill_level parameter accepts LOW or HIGH (note: uppercase, unlike the tier list endpoint) to shift the statistical context. The response also includes the numeric champion_id alongside the slug, which is useful for cross-referencing with other League data sources.
The Mobalytics API is a managed, monitored endpoint for mobalytics.gg — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when mobalytics.gg changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official mobalytics.gg API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Display a live S-tier champion list for a given role in a draft-assist tool, using
get_tier_listfiltered byrole. - Show recommended rune pages and item builds inside a companion app, pulling from
get_champion_buildfor the user's selected champion and role. - Surface counter-pick suggestions during champion select by reading the
countersarrays fromget_champion_stats. - Compare win rate and pick rate across patches by periodically polling
get_champion_buildfor each champion and storing thepatchandstatsfields. - Build a low-elo vs. high-elo tier difference view by calling
get_tier_listtwice withskill_levelset tolow-eloandhigh-eloand diffing the results. - Populate a champion overview card with aggregated stats across all roles a champion plays, using the
rolesarray fromget_champion_stats.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Mobalytics have an official public developer API?+
How does the `skill_level` filter work across endpoints, and are the accepted values the same?+
skill_level use different value formats. get_tier_list accepts low-elo or high-elo (lowercase, hyphenated), while get_champion_stats accepts LOW or HIGH (uppercase). Passing the wrong case to either endpoint will not produce the intended filtering.Does the API return historical tier list data or builds from previous patches?+
patch field in get_champion_build tells you which patch the build is sourced from, but there is no historical query parameter. You can fork this API on Parse and revise it to add snapshot storage or historical patch lookups.Does the API cover ARAM, URF, or other non-Summoner's Rift game modes?+
What does the `build` object in `get_champion_build` actually contain?+
build object contains four fields: skill_order (the recommended ability leveling sequence), summoner_spells (the two suggested summoner spells), runes (the recommended rune page), and items (the recommended item build path). All values reflect the most popular build among Emerald+ ranked games on the current patch.