# Esports Earnings Prize Money & Tournament Rankings (`xyrelith-data/esports-earnings-prize-money-and-tournament`) Actor

Pull player, team, game and tournament prize-money rankings from EsportsEarnings.com, with per-game and per-country filters and career-earnings totals in USD.

- **URL**: https://apify.com/xyrelith-data/esports-earnings-prize-money-and-tournament.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (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

## Esports Earnings Prize Money & Tournament Rankings

EsportsEarnings.com tracks competitive-gaming prize money across hundreds of games, tens of thousands of tournaments and more than 100,000 players. This actor turns that catalog into structured records: career and year-by-year earnings rankings, the full country leaderboard, detail profiles for players and teams, and tournament prize distributions down to each placement, team and player.

### What this actor does

- **Nine modes:** `topPlayers`, `topTeams`, `topGames`, `tournaments`, `topPlayersByCountry`, `topCountries`, `playerProfile`, `teamProfile`, `tournamentProfile`
- **Earnings rankings** for players and teams — overall, for one game, for one calendar year, or for one month
- **Game and country rankings** — top games by prize pool and all 180+ countries by total prize money
- **Tournament lists** — overall largest prize pools, largest tournament for a chosen game, or every tournament that ended in a chosen year
- **Player profiles** — date of birth, world/country ranking, earnings by year, game and team, highest single prizes, and Champion/Runner-up/Semi-final counts
- **Team profiles** — total prize money, tournament count, per-game earnings, country breakdown and top-earning players
- **Tournament profiles** — location, dates, currency, full placement table (including tied ranks such as `5th-6th`), team rosters and prize-money-by-country
- 28 popular games in a dropdown, plus a free-text override for any other tracked game; 182 countries in the country dropdown
- Empty fields are omitted from every record

### Modes and inputs

| Mode | What it returns | Required inputs |
|---|---|---|
| `topPlayers` | Player earnings ranking | – |
| `topTeams` | Team earnings ranking | – |
| `topGames` | Games ranked by total prize money | – |
| `tournaments` | Tournaments ranked by prize pool | – (a `game` narrows it to that game) |
| `topPlayersByCountry` | Top 25 earners for one country | `country` |
| `topCountries` | Country leaderboard by total prize money | – |
| `playerProfile` | Detailed player profile | `playerIds` |
| `teamProfile` | Detailed team profile | `teamIds` |
| `tournamentProfile` | Tournament info + full prize distribution | `tournamentIds` |

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `topPlayers` | One of the nine modes above |
| `game` | string | – | Filter to one game (dropdown of 28 popular titles). Leave blank for cross-game rankings and the overall tournament list. |
| `gameCustom` | string | – | Any game in `{numericId}-{slug}` form (e.g. `654-arena-of-valor`). Overrides `game`. |
| `year` | integer | – | History ranking year (1998–today) for `topPlayers`, `topTeams`, `topGames`, `topCountries` and `tournaments`. Ignored when a `game` filter is set. |
| `month` | integer | – | Month 1–12 for `topPlayers` when `year` is set. |
| `country` | string | – | ISO 3166-1 alpha-2 code (dropdown of 182 countries). Required for `topPlayersByCountry`. |
| `playerIds` | array | – | Players for `playerProfile`: numeric ID, id-slug, path or full URL. |
| `teamIds` | array | – | Teams for `teamProfile`: numeric ID, id-slug, path or full URL. |
| `tournamentIds` | array | – | Tournaments for `tournamentProfile`: numeric ID, id-slug, path or full URL. |
| `maxItems` | integer | `30` | Maximum records to return (1–1000). |

Profile lists accept links copied straight from the browser, for example `https://www.esportsearnings.com/players/3304-n0tail-johan-sundstein`, `/players/3304-n0tail-johan-sundstein`, `3304-n0tail-johan-sundstein` or just `3304`.

### Output per record type

#### Player (`recordType = "player"`)

List modes: `rank`, `handle`, `realName`, `playerId`, `country`, `countryCode`, `totalEarningsUsd`, `highestPayingGame`, `highestPayingGameEarningsUsd`, `percentOfTotal`, `game` (game filter), `year`, `month`, `sourceUrl`.

`playerProfile` adds: `dateOfBirth`, `age`, `worldRanking`, `countryRanking`, `tournamentCount`, `alternateIds`, `earningsByYear` (total/online/offline money, tournament count, % of total), `earningsByGame`, `earningsByTeam`, `highestPrizes` (date, placement, tournament, prize, game) and `topPlacements` (Champion / Runner-up / 3rd-Semis counts).

#### Team (`recordType = "team"`)

List modes: `rank`, `teamName`, `teamId`, `totalEarningsUsd`, `tournamentCount`, `game` (game filter), `year`, `sourceUrl`.

`teamProfile` adds: `games` (per-game earnings and % of team total), `countries` (prize money by player country) and `topPlayers` (handle, real name and earnings with the team).

#### Game (`recordType = "game"`)

`rank`, `gameName`, `gameSlug`, `totalPrizeMoneyUsd`, `playerCount`, `tournamentCount`, `year`, `sourceUrl`.

#### Tournament (`recordType = "tournament"`)

List modes: `rank`, `tournamentName`, `tournamentId`, `eventName`, `prizePoolUsd`, `teamCount`, `playerCount`, `teamplay`, `game`, `gameSlug`, `date` (year events), `year`, `sourceUrl`.

`tournamentProfile` adds: `location`, `startDate`, `endDate`, `currencyCode`, `currencyName`, `placements` (rank text, prize, team and roster or individual player) and `countries` (prize money by country).

#### Country (`recordType = "country"`)

`rank`, `country`, `countryCode`, `totalEarningsUsd`, `playerCount`, `topGame`, `topGameSlug`, `topGameEarningsUsd`, `percentOfTotal`, `year`, `sourceUrl`.

### Examples

#### Top players overall

```json
{ "mode": "topPlayers", "maxItems": 50 }
```

#### Top Dota 2 players

```json
{ "mode": "topPlayers", "game": "231-dota-2", "maxItems": 50 }
```

#### The 2021 player earnings ranking

```json
{ "mode": "topPlayers", "year": 2021, "maxItems": 100 }
```

#### January 2021 player ranking

```json
{ "mode": "topPlayers", "year": 2021, "month": 1, "maxItems": 100 }
```

#### 2021 team and game rankings

```json
{ "mode": "topTeams", "year": 2021, "maxItems": 100 }
```

#### Every tournament that ended in 2021

```json
{ "mode": "tournaments", "year": 2021, "maxItems": 500 }
```

#### Largest Counter-Strike 2 tournaments

```json
{ "mode": "tournaments", "game": "839-counter-strike-2", "maxItems": 50 }
```

#### Country leaderboard

```json
{ "mode": "topCountries", "maxItems": 50 }
```

#### Top-earning Danish players

```json
{ "mode": "topPlayersByCountry", "country": "dk", "maxItems": 25 }
```

#### Player profiles by URL and ID

```json
{
  "mode": "playerProfile",
  "playerIds": [
    "https://www.esportsearnings.com/players/3304-n0tail-johan-sundstein",
    "15855-miposhka-yaroslav-naidenov"
  ]
}
```

#### A tournament's full prize distribution

```json
{ "mode": "tournamentProfile", "tournamentIds": ["49174-the-international-2021"] }
```

### Use cases

- **Esports journalism** — automate top-earner tables, year-in-review leaderboards and tournament prize breakdowns
- **Talent scouting and team management** — compare player earnings by year, game and team
- **Sponsorship analytics** — find the highest-prize-pool games, teams and countries to target
- **Fan platforms and fantasy esports** — power leaderboards and profile pages with live earnings data
- **Market research** — track prize-money growth by year, game and region

### Depth and limits

- `topPlayers` overall: 1,000 players. `topTeams` overall: 500. Overall `tournaments`: 500.
- Per-game lists: `topPlayers` and `tournaments` stop at 500; per-game `topTeams` depth varies with the game's team count (e.g. Dota 2: 283).
- `topGames` overall: 100 games on the source's single page.
- History: year/month `topPlayers` stop at 500. Year teams, games and countries are single pages (up to ~857 / 209 / 132 rows respectively). Year events is a single page too; `maxItems` caps the output at 1,000.
- `topCountries`: all 183 ranked countries. `topPlayersByCountry`: the source's fixed top-25 page.
- Profile modes fetch one page per target, so `maxItems` also caps how many targets are read.

The actor detects the source's repeated-last-page behaviour when a listing is exhausted and stops cleanly instead of emitting duplicates.

### FAQ

**What is the data source?**
All data comes from the public pages of [EsportsEarnings.com](https://www.esportsearnings.com), a long-running independent database of competitive-gaming tournament results and prize money.

**Is this actor affiliated with Esports Earnings?**
No — this is an independent, third-party actor that reads publicly available pages. It is not affiliated with or endorsed by Esports Earnings.

**How do I find a game's ID-slug?**
Open the game on esportsearnings.com and copy the last part of the URL: `esportsearnings.com/games/654-arena-of-valor` → `654-arena-of-valor`. The numeric prefix is required.

**Why do some player records have `highestPayingGame` and others don't?**
When no game filter is set, the list record shows each player's single highest-earning game. With a game filter, every record is already scoped to that game, so the field is omitted as redundant.

**How is `totalEarningsUsd` calculated?**
It mirrors what the source displays: career earnings in US dollars, or the game-specific / year-specific total when a filter is set. Profile breakdowns use the same USD values the site computes.

**Does a tournament profile include every placement?**
Yes — the parser walks every placement block, including tied ranks like `5th-6th` (one entry per team sharing that rank and prize) and individual events where the placement is a player rather than a team.

**What about tournaments listed in another currency?**
All prize fields are normalised to US dollars. For tournaments listed in another currency (for example CNY), the actor uses the USD conversion the source displays next to the original amount.

**How fresh is the data?**
Every run fetches live pages at request time; there is no caching.

**Why are some profile fields missing on a few records?**
Some teams have no roster table and some events have no country breakdown on the source page. Those fields are omitted rather than filled with placeholders.

**Can I use the official EsportsEarnings API?**
There is an official API, but it needs a registered API key. This actor deliberately uses the public HTML so it works with no credentials and no setup.

# Actor input Schema

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

What to fetch from Esports Earnings. Profile modes need the matching `playerIds`, `teamIds`, or `tournamentIds` list.

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

Filter to a specific game. Leave blank on topPlayers/topTeams for cross-game rankings and on tournaments for the overall largest-prize-pools list. Use `gameCustom` for games not in this list.

## `country` (type: `string`):

ISO 3166-1 alpha-2 country code. Returns that country's top-earning players, cross-game (esportsearnings.com's per-country breakdown page).

## `gameCustom` (type: `string`):

Any esportsearnings.com game in `{numericId}-{slug}` form (e.g. `654-arena-of-valor`), for games not in the `game` dropdown. Overrides `game` when set. Find the ID-slug in the game's esportsearnings.com URL.

## `year` (type: `integer`):

Rank players/teams/games/countries or list tournaments for one year (1998 to today). Applies to topPlayers, topTeams, topGames, topCountries and tournaments. Ignored when a game filter is also set on topPlayers/topTeams/tournaments.

## `month` (type: `integer`):

Optional month (1-12) for mode=topPlayers when `year` is set. Returns that month's player earnings ranking.

## `playerIds` (type: `array`):

One or more players. Each entry can be a numeric player ID (e.g. 3304), an id-slug (e.g. 3304-n0tail-johan-sundstein), an esportsearnings.com player path, or a full URL.

## `teamIds` (type: `array`):

One or more teams. Each entry can be a numeric team ID (e.g. 102), an id-slug (e.g. 102-team-liquid), an esportsearnings.com team path, or a full URL.

## `tournamentIds` (type: `array`):

One or more tournaments. Each entry can be a numeric tournament ID (e.g. 49174), an id-slug, an esportsearnings.com tournament path, or a full URL.

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

Maximum number of records to return.

## Actor input object example

```json
{
  "mode": "topPlayers",
  "game": "",
  "country": "us",
  "maxItems": 3
}
```

# Actor output Schema

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

Dataset containing all scraped Esports Earnings players, teams, games, and tournaments.

# 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": "topPlayers",
    "game": "",
    "country": "us",
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/esports-earnings-prize-money-and-tournament").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": "topPlayers",
    "game": "",
    "country": "us",
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/esports-earnings-prize-money-and-tournament").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": "topPlayers",
  "game": "",
  "country": "us",
  "maxItems": 3
}' |
apify call xyrelith-data/esports-earnings-prize-money-and-tournament --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/esports-earnings-prize-money-and-tournament"
        }
    }
}
```

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/qK3vNllolITWHfX52/builds/3JoviiLtsUgJj1fRI/openapi.json
