# Lichess Chess Users Scraper (`parseforge/lichess-chess-users-scraper`) Actor

Scrape chess player profiles, ratings, and game stats from Lichess public API. Get user info, rating per variant, recent games, online status, tournament history. No API key required.

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

## Pricing

from $30.90 / 1,000 results

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://raw.githubusercontent.com/ParseForge/apify-assets/main/parseforge-banner.png)

## ♟️ Lichess Chess Users Scraper

> 🚀 **Export full Lichess player profiles in seconds.** Multi-variant ratings, lifetime game counts, training scores, real names, and streaming links. No API key, no OAuth, no scraping HTML.

> 🕒 **Last updated:** 2026-05-12 · **📊 50 fields** per record · **♟️ 12 chess variants** · **🌍 Lichess: 14M+ registered users** · **🔓 Free open-source platform**

The **Lichess Chess Users Scraper** pulls full public player profiles from Lichess via its open public API. Pass a list of usernames and the Actor returns **50 fields per record**, including ratings and game counts across 12 chess variants (bullet, blitz, rapid, classical, correspondence, ultra-bullet, chess960, king of the hill, three-check, antichess, atomic, horde, racing kings, crazyhouse), training scores (puzzle, storm, racer, streak), lifetime play time and TV time, real name, country flag, FIDE and USCF ratings, bio text, profile links, GM/IM/NM titles, patron status, and Twitch/YouTube streaming channels.

Lichess is the world's leading free and open-source chess platform with 14 million+ registered users, including most current top grandmasters playing under aliases. The official API returns rich profile data without authentication, making this Actor ideal for chess analytics, coaching platforms, tournament management, streaming dashboards, and esports research.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Chess coaches, esports analysts, tournament organizers, chess content creators, streaming dashboards, training-app developers, chess data scientists | Player rating dashboards, GM scouting, tournament seeding, streamer aggregation, training-tool integration, multi-variant strength comparisons, chess statistics research |

---

### 📋 What the Lichess Chess Users Scraper does

One simple workflow with rich output:

- 📋 **Batch profile lookup.** Pass any list of Lichess usernames and pull each profile in one run.
- 🎯 **12 variant ratings.** Bullet, blitz, rapid, classical, correspondence, ultra-bullet, chess960, king of the hill, three-check, antichess, atomic, horde, racing kings, crazyhouse.
- 🧩 **Training scores.** Puzzle rating and games, storm score, racer score, streak score.
- 📺 **Streaming links.** Twitch and YouTube channels for streamer aggregation.

Each record includes a stable user ID, profile URL, title (GM/IM/FM/NM/CM/WGM/etc.), patron flag, verified flag, profile flair emoji, account creation and last-seen timestamps, bio text, real name, country flag, FIDE and USCF ratings, profile links, lifetime play time in seconds, TV-watched time, total games (all, rated, win, loss, draw, import), per-variant ratings and game counts, and currently-playing game URL when the player is online.

> 💡 **Why it matters:** scraping per-player HTML pages on Lichess is fragile and slow. The public API is fast and stable, but most users only want clean structured rows for spreadsheets and dashboards. This Actor takes a list of usernames and returns a flat table ready to load into BI tools, training apps, or tournament-management systems.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>usernames</code></td><td>string[]</td><td><code>["thibault"]</code></td><td>List of Lichess usernames to scrape. Case-insensitive.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: world-class GM profiles in one run.**

```json
{
    "usernames": ["DrNykterstein", "penguingm1", "Hikaru", "fabianoCaruana", "Anish_Giri"],
    "maxItems": 50
}
````

**Example: full team roster for a chess club.**

```json
{
    "usernames": ["thibault", "ornicar", "veloce", "isaacly", "lichess-tools"],
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** closed or disabled accounts return minimal data with a `closed: true` flag. Variant ratings with zero games show `null`. The Lichess API rate-limits aggressive callers, so the Actor paces requests at 200ms per user.

***

### 📊 Output

Each player record contains up to **50 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"thibault"` |
| 🔗 `url` | string | `"https://lichess.org/@/thibault"` |
| 👤 `username` | string | `"thibault"` |
| 🏆 `title` | string | null | `"GM"` |
| 💎 `patron` | boolean | null | `true` |
| ✅ `verified` | boolean | null | `true` |
| 🎨 `flair` | string | null | `"nature.seedling"` |
| 📅 `createdAt` | ISO 8601 | null | `"2010-11-22T08:48:00.000Z"` |
| 👀 `seenAt` | ISO 8601 | null | `"2026-05-12T16:27:49.437Z"` |
| 📝 `bio` | string | null | `"I turn coffee into bugs."` |
| 👤 `realName` | string | null | `"Thibault Duplessis"` |
| 🌍 `country` | string | null | `"FR"` |
| 🏆 `fideRating` | number | null | `2551` |
| 🏆 `uscfRating` | number | null | `2616` |
| 🔗 `links` | string | null | `"github.com/ornicar"` |
| ⏱️ `playTimeSeconds` | number | null | `6501435` |
| 📺 `tvTimeSeconds` | number | null | `18024` |
| 🎮 `gamesAll` | number | null | `23585` |
| 🎮 `gamesRated` | number | null | `21193` |
| 🏆 `gamesWin` | number | null | `11276` |
| ❌ `gamesLoss` | number | null | `11268` |
| 🤝 `gamesDraw` | number | null | `1036` |
| 📥 `gamesImport` | number | null | `73` |
| 🔫 `bulletRating` | number | null | `1785` |
| 🔫 `bulletGames` | number | null | `7482` |
| ⚡ `blitzRating` | number | null | `1805` |
| ⚡ `blitzGames` | number | null | `11612` |
| 🏃 `rapidRating` | number | null | `1907` |
| 🏃 `rapidGames` | number | null | `894` |
| 🐢 `classicalRating` | number | null | `1858` |
| 🐢 `classicalGames` | number | null | `25` |
| 📮 `correspondenceRating` | number | null | `1942` |
| 🚀 `ultraBulletRating` | number | null | `1688` |
| 🚀 `ultraBulletGames` | number | null | `3` |
| 🎲 `chess960Rating` | number | null | `1551` |
| 🎲 `chess960Games` | number | null | `348` |
| 👑 `kingOfTheHillRating` | number | null | `1744` |
| ➕ `threeCheckRating` | number | null | `1728` |
| 🔄 `antichessRating` | number | null | `1465` |
| 💥 `atomicRating` | number | null | `1633` |
| 🐴 `hordeRating` | number | null | `1592` |
| 🏎️ `racingKingsRating` | number | null | `1552` |
| 🤪 `crazyhouseRating` | number | null | `1567` |
| 🧩 `puzzleRating` | number | null | `1986` |
| 🧩 `puzzleGames` | number | null | `5873` |
| ⚡ `stormScore` | number | null | `33` |
| 🏁 `racerScore` | number | null | `51` |
| 🔥 `streakScore` | number | null | `33` |
| 📺 `twitchChannel` | string | null | `"https://www.twitch.tv/ornicar2"` |
| 📺 `youtubeChannel` | string | null | `"https://youtube.com/channel/..."` |
| 🎮 `playing` | string | null | `"https://lichess.org/R8X0l6Ym/black"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-12T16:30:27.977Z"` |

#### 📦 Sample records

<details>
<summary><strong>♟️ thibault (Lichess founder, multi-variant veteran)</strong></summary>

```json
{
    "id": "thibault",
    "url": "https://lichess.org/@/thibault",
    "username": "thibault",
    "title": null,
    "patron": true,
    "verified": true,
    "flair": "nature.seedling",
    "createdAt": "2010-11-22T08:48:00.000Z",
    "seenAt": "2026-05-12T16:27:49.437Z",
    "bio": "I turn coffee into bugs.",
    "realName": "Thibault Duplessis",
    "links": "github.com/ornicar\r\nmas.to/@thibault",
    "playTimeSeconds": 6501435,
    "gamesAll": 23585,
    "bulletRating": 1785,
    "blitzRating": 1805,
    "rapidRating": 1907,
    "classicalRating": 1858,
    "puzzleRating": 1986,
    "twitchChannel": "https://www.twitch.tv/ornicar2",
    "playing": "https://lichess.org/R8X0l6Ym/black",
    "scrapedAt": "2026-05-12T16:30:27.977Z"
}
```

</details>

<details>
<summary><strong>👑 DrNykterstein (titled GM, world top-level bullet rating)</strong></summary>

```json
{
    "id": "drnykterstein",
    "url": "https://lichess.org/@/DrNykterstein",
    "username": "DrNykterstein",
    "title": "GM",
    "patron": true,
    "flair": "people.santa-claus-light-skin-tone",
    "createdAt": "2018-12-06T12:44:50.814Z",
    "seenAt": "2026-04-25T18:23:10.010Z",
    "playTimeSeconds": 1169601,
    "tvTimeSeconds": 665451,
    "gamesAll": 10450,
    "gamesWin": 7207,
    "bulletRating": 3243,
    "bulletGames": 9583,
    "blitzRating": 3153,
    "chess960Rating": 2541,
    "twitchChannel": "https://www.twitch.tv/maskenissen",
    "scrapedAt": "2026-05-12T16:30:28.389Z"
}
```

</details>

<details>
<summary><strong>🐧 penguingim1 (GM Andrew Tang, all 12 variants active with full FIDE/USCF ratings)</strong></summary>

```json
{
    "id": "penguingim1",
    "url": "https://lichess.org/@/penguingim1",
    "username": "penguingim1",
    "title": "GM",
    "patron": true,
    "flair": "nature.penguin",
    "realName": "Andrew Tang",
    "country": "AQ",
    "fideRating": 2551,
    "uscfRating": 2616,
    "playTimeSeconds": 8121725,
    "gamesAll": 78012,
    "gamesWin": 60802,
    "bulletRating": 3196,
    "blitzRating": 2719,
    "ultraBulletRating": 2769,
    "puzzleRating": 2554,
    "stormScore": 100,
    "twitchChannel": "https://www.twitch.tv/penguingm1",
    "youtubeChannel": "https://www.youtube.com/channel/UCcJxY7NovRrYCsxyl6qaFLA/live",
    "scrapedAt": "2026-05-12T16:30:28.696Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| ♟️ | **12 variant ratings.** Every chess flavor Lichess supports, including chess960, atomic, and horde. |
| 🧩 | **Training scores included.** Puzzle, storm, racer, and streak in one row alongside ratings. |
| 📺 | **Streamer-ready.** Twitch and YouTube channels pre-extracted for aggregator dashboards. |
| 🏆 | **External ratings.** FIDE and USCF numbers when the user has set them in their profile. |
| ⏱️ | **Lifetime play time.** Total seconds of chess played and time spent on Lichess TV. |
| 🔓 | **Open-source ecosystem.** Lichess is free and open-source; this Actor respects the API rate limits. |
| 🚫 | **No login or OAuth.** Public endpoints only, no token management. |

> 📊 Lichess hosts the world's largest free chess community with 14M+ registered users and millions of daily games played.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Lichess Chess Users Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **Any Lichess username** | **Live per run** | usernames, maxItems | ⚡ 2 min |
| Paid chess analytics APIs | $49+/month | Subset | Daily | Vendor-defined | ⏳ Hours |
| Manual HTML scraping of profile pages | Free | One profile at a time | Manual | None | 🐢 Days |
| Single-profile API calls in code | Free | DIY | Live | Code-defined | 🛠️ Hours |

Pick this Actor when you need clean profile rows for many players at once without writing your own batch pipeline.

***

### 🚀 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 Lichess Chess Users Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a list of Lichess usernames and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor walk the usernames list.
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">

#### ♟️ Chess Coaches & Academies

- Student progress dashboards across variants
- Rating-based homework assignments
- Cohort comparisons by puzzle rating
- Online presence tracking via `seenAt`

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

#### 🏆 Tournament Organizers

- Pre-tournament seeding by blitz or rapid rating
- Anti-cheat baselines via game counts
- Player verification with title flag
- Bracket pairings using FIDE rating

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

#### 📺 Streamer Aggregation

- Live-streamer lists with Twitch/YouTube links
- Rating-leaderboard widgets for stream overlays
- Cross-platform discovery feeds
- Chess-content directories

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

#### 📊 Esports & Research

- Multi-variant strength comparison studies
- Rating distribution histograms
- Improvement curves by training score
- Geographic mapping by country flag

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

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

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

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

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

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

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

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

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

***

### 🔌 Automating Lichess Chess Users 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. Daily refreshes keep coaching dashboards and tournament rosters in sync automatically.

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Provide a list of Lichess usernames, click Start, and the Actor calls the public `/api/user/{username}` endpoint for each one, paces requests to respect rate limits, and emits a clean structured record per profile.

#### 🏆 What chess titles can appear?

Lichess displays titles such as GM, IM, FM, CM, NM, WGM, WIM, WFM, WCM, WNM, LM (Lichess Master) and BOT (for bot accounts). The `title` field reflects whatever the player has set after verification.

#### ♟️ Why are some variant ratings null?

A `null` value means the player has not played that variant yet. Lichess assigns a provisional rating only after a few games in each variant.

#### 📺 Why is `country` sometimes a flag string and sometimes null?

Players can pick any flag from the Lichess flag list. The field returns the raw flag code (e.g. `FR`, `AQ`, or fun choices like `AQ` for Antarctica). It is `null` when the user has not set one.

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

Every run pulls live profile data. Ratings update after each rated game, so the `seenAt` and rating fields can move minute-by-minute for active players.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync.

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

Lichess publishes all profile data via its public open-source API. Profiles are publicly visible by default. Review the Lichess terms of service before mass redistribution.

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

Lichess is licensed AGPL and the API is permissive for non-abusive use. Public profile data may be used for analytics, dashboards, and research. Respect the Lichess API terms regarding rate limits and attribution.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Lichess Chess Users 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 run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe chess 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 chess data into your coaching app, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🐉 EDHREC MTG Commander Scraper**](https://apify.com/parseforge/edhrec-mtg-commander-scraper) - Magic: The Gathering Commander format meta statistics
- [**🎮 BoardGameGeek Scraper**](https://apify.com/parseforge/boardgamegeek-scraper) - Board game ratings, rankings, and reviews
- [**🎯 Manifold Prediction Markets Scraper**](https://apify.com/parseforge/manifold-prediction-markets-scraper) - Public prediction market questions and probabilities
- [**📺 Twitch Scraper**](https://apify.com/parseforge/twitch-scraper) - Twitch channels, streams, and viewership data
- [**▶️ YouTube Channel Scraper**](https://apify.com/parseforge/youtube-channel-scraper) - YouTube channels, videos, and metrics

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more games, esports, and community-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 Lichess.org or its volunteer maintainers. All trademarks mentioned are the property of their respective owners. Only publicly available profile data is collected.

# Actor input Schema

## `usernames` (type: `array`):

List of Lichess usernames to scrape (e.g. thibault, DrNykterstein, magnuscarlsen)

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

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

## Actor input object example

```json
{
  "usernames": [
    "thibault"
  ],
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "usernames": [
        "thibault"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/lichess-chess-users-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 = {
    "usernames": ["thibault"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/lichess-chess-users-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 '{
  "usernames": [
    "thibault"
  ],
  "maxItems": 10
}' |
apify call parseforge/lichess-chess-users-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lichess Chess Users Scraper",
        "description": "Scrape chess player profiles, ratings, and game stats from Lichess public API. Get user info, rating per variant, recent games, online status, tournament history. No API key required.",
        "version": "0.0",
        "x-build-id": "UkAHI286fZxe55Ies"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~lichess-chess-users-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-lichess-chess-users-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~lichess-chess-users-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-lichess-chess-users-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~lichess-chess-users-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-lichess-chess-users-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",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Lichess usernames",
                        "type": "array",
                        "description": "List of Lichess usernames to scrape (e.g. thibault, DrNykterstein, magnuscarlsen)",
                        "default": [
                            "thibault"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
