# Codeforces Competitive Programming Scraper (`parseforge/codeforces-scraper`) Actor

Scrape Codeforces public API for user info, contest history, problem set, and submission stats. Get rating, rank, country, max rating, and 8000+ problems. No API key required.

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

## Pricing

from $31.05 / 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)

## 🏆 Codeforces Competitive Programming Scraper

> 🚀 **Pull Codeforces profiles, problems, contests, and leaderboards in seconds.** Filter by handle, tag, contest type, or active status. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-12 · **📊 Up to 19 fields** per record · **8,000+ problems** indexed · **Hundreds of thousands of rated users** · **All public contests since 2010**

The Codeforces Competitive Programming Scraper turns the official **Codeforces public API** into a clean, ready-to-use dataset. Codeforces is the world's most active competitive programming community, hosting weekly contests, a graded problem archive, and a global rating ladder used by recruiters, schools, and contest analysts. This actor exposes four modes that cover the catalog: **user profiles**, **the full problem set**, **the complete contest list**, and **the rated users leaderboard**.

Each mode emits a flat JSON record with stable identifiers, scored fields, and a direct URL back to Codeforces. Profile records carry rating and rank history, country, organization, and contribution score. Problem records carry difficulty rating, tags, solve count, and solve share. Contest records carry phase, duration, ICPC region, and ICPC season. Leaderboard records sort highest-rating-first so you can grab the top 100, 1,000, or 10,000 players in one run.

| 🎯 Target audience | 💼 Primary use cases |
|---|---|
| Tech recruiters | Source talent and benchmark candidate skill levels |
| Coaches and trainers | Build curated problem sets for students by tag and rating |
| Contest organizers | Audit historical contests, archives, and ICPC entries |
| Researchers | Study competitive programming demographics and rating dynamics |
| Tooling and community sites | Sync Codeforces metadata into dashboards and leaderboards |

---

### 📋 What the Codeforces Scraper does

- 👤 **User mode.** Pass a list of handles like `tourist`, `Petr`, `Benq` and get rating, max rating, rank, country, organization, registration date, and contribution score in one call.
- 🧩 **Problem set mode.** Pull the full archive of 8,000+ problems with rating, tags, contest id, solve count, and solve share.
- 🏟️ **Contest list mode.** Fetch every public contest with phase, type, duration, ICPC region, country, and start time. Optional gym contests via a toggle.
- 🏅 **Rated users mode.** Stream the global leaderboard sorted by rating, with optional active-only filter.
- 🏷️ **Tag filtering.** Restrict problems to specific topics like `dp`, `graphs`, `binary search`, `math`, `greedy`, or any official Codeforces tag.
- 📦 **Bulk-friendly.** User mode batches in chunks of 100 to respect the API and complete large jobs quickly.

Each record includes a `mode` discriminator (`user`, `problem`, `contest`, or `ratedUser`) so you can union the four shapes in one downstream table without losing track of which mode produced each row.

> 💡 **Why it matters:** Codeforces is the de facto benchmark for algorithmic skill. A structured pull of profiles, problems, and contest history powers recruiting funnels, coaching tools, research papers, and community dashboards without you maintaining custom API code.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing how to pick a mode, filter by tag, and route results into a spreadsheet or database.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td><code>mode</code></td><td>enum</td><td>One of <code>users</code>, <code>problemset</code>, <code>contests</code>, or <code>ratedList</code>. Default <code>users</code>.</td></tr>
<tr><td><code>handles</code></td><td>array</td><td>List of Codeforces handles. Required in <code>users</code> mode.</td></tr>
<tr><td><code>tags</code></td><td>array</td><td>Problem tag filter for <code>problemset</code> mode. Example <code>["dp", "graphs"]</code>.</td></tr>
<tr><td><code>gym</code></td><td>boolean</td><td>Include gym (training) contests in <code>contests</code> mode.</td></tr>
<tr><td><code>activeOnly</code></td><td>boolean</td><td>Restrict <code>ratedList</code> to recently active rated users.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>Free users 10, paid users up to 1,000,000.</td></tr>
</table>

Example: top 100 active rated users.

```json
{
  "mode": "ratedList",
  "activeOnly": true,
  "maxItems": 100
}
````

Example: dynamic programming problems sorted by Codeforces order.

```json
{
  "mode": "problemset",
  "tags": ["dp", "trees"],
  "maxItems": 200
}
```

> ⚠️ **Good to Know:** Codeforces caps the rated list response size, so very large `ratedList` requests may take longer to return. User mode automatically batches handles in groups of 100 to stay friendly with the public API.

***

### 📊 Output

Each record is a flat JSON object with the fields below. Field availability depends on the chosen mode.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `mode` | string | `problem` |
| 👤 `handle` | string | `tourist` |
| 🔗 `url` | string | `https://codeforces.com/profile/tourist` |
| 🖼️ `avatar` | string | `https://userpic.codeforces.org/.../avatar` |
| ⭐ `rating` | number | `3853` |
| 🏔️ `maxRating` | number | `3979` |
| 🏷️ `rank` | string | `legendary grandmaster` |
| 🏷️ `maxRank` | string | `legendary grandmaster` |
| 🌍 `country` | string | `Belarus` |
| 🏢 `organization` | string | `ITMO University` |
| 📈 `contribution` | number | `175` |
| 🗓️ `registrationTime` | string | `2010-04-13T07:33:34.000Z` |
| 🧩 `contestId` | number | `2227` |
| 🔤 `index` | string | `H` |
| 🏷️ `name` | string | `Fallen Leaves` |
| 🏔️ `problemRating` | number | `2400` |
| 🏷️ `tags` | array | `["dp", "trees"]` |
| 🧮 `solvedCount` | number | `1150` |
| 📊 `solvedSharePercent` | number | `0.001035` |
| ⏱️ `scrapedAt` | string | `2026-05-12T16:30:28.571Z` |

#### 📦 Sample records

<details>
<summary>Typical: hard problem with multiple tags</summary>

```json
{
  "contestId": 2227,
  "index": "H",
  "url": "https://codeforces.com/problemset/problem/2227/H",
  "contestUrl": "https://codeforces.com/contest/2227",
  "name": "Fallen Leaves",
  "type": "PROGRAMMING",
  "rating": null,
  "tags": ["dfs and similar", "dp", "trees"],
  "tagsCount": 3,
  "solvedCount": 1150,
  "solvedSharePercent": 0.001035,
  "points": null,
  "mode": "problem",
  "scrapedAt": "2026-05-12T16:30:28.571Z"
}
```

</details>

<details>
<summary>Edge case: high-frequency tag set with binary search</summary>

```json
{
  "contestId": 2227,
  "index": "F",
  "url": "https://codeforces.com/problemset/problem/2227/F",
  "contestUrl": "https://codeforces.com/contest/2227",
  "name": "It Just Keeps Going Sideways",
  "type": "PROGRAMMING",
  "tags": ["binary search", "data structures", "dp", "greedy", "math"],
  "tagsCount": 5,
  "solvedCount": 3155,
  "solvedSharePercent": 0.002839,
  "mode": "problem",
  "scrapedAt": "2026-05-12T16:30:28.571Z"
}
```

</details>

<details>
<summary>Sparse: classic data-structures problem with no points</summary>

```json
{
  "contestId": 2227,
  "index": "G",
  "url": "https://codeforces.com/problemset/problem/2227/G",
  "contestUrl": "https://codeforces.com/contest/2227",
  "name": "Drowning",
  "type": "PROGRAMMING",
  "tags": ["binary search", "data structures", "math"],
  "tagsCount": 3,
  "solvedCount": 1538,
  "solvedSharePercent": 0.001384,
  "mode": "problem",
  "scrapedAt": "2026-05-12T16:30:28.571Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🆓 | **No API key.** Codeforces exposes a public API, and this actor inherits that. |
| 🎚️ | **Four modes, one schema family.** Profiles, problems, contests, and rated users share the same flat shape. |
| 🏷️ | **Tag filtering.** Pull all `dp` or `graphs` problems with one line of input. |
| 🧮 | **Solve stats built in.** Each problem record carries `solvedCount` and `solvedSharePercent`. |
| ⚡ | **Bulk-friendly.** Handles are batched in chunks of 100 for fast multi-profile pulls. |
| 🏔️ | **Leaderboard ready.** Rated users come pre-sorted by rating, top first. |
| 🔌 | **Integrates everywhere.** Land results in Sheets, Notion, Slack, or a database. |

> 📊 8,000+ problems, 4 modes, 1 free actor.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Codeforces Scraper** *(this Actor)* | Free tier available | Profiles, problems, contests, rated users | On-demand | Handle, tag, gym, active | One JSON input |
| Direct API integration | Engineering time | Whatever you build | Custom | Custom code | High |
| Community CSV dumps | Free | Snapshot only | None | None | Manual download |
| Paid talent intel platforms | $100+ per month | Often broader | Daily | Vendor-specific | Account, key, SDK |

For teams that want a working Codeforces feed without writing API client code, this actor is the shortest path from request to row.

***

### 🚀 How to use

1. 🔐 **Create a free Apify account.** Sign up at [Apify](https://console.apify.com/sign-up?fpr=vmoqkp) and claim the $5 starter credit.
2. 🎚️ **Open the actor and pick a mode.** Choose `users`, `problemset`, `contests`, or `ratedList`.
3. 🧩 **Set the filters.** Add handles, tags, gym toggle, or active-only as needed.
4. ▶️ **Run it.** Free users get a 10-row preview, paid users can pull up to 1,000,000 records per run.
5. 📤 **Export.** Download JSON, CSV, or Excel, or push results into Google Sheets, Airtable, Slack, Notion, or a database via Apify integrations.

> ⏱️ Total time from sign-up to first dataset: about 90 seconds.

***

### 💼 Business use cases

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

#### 🎯 Tech recruiting

- Source candidates by minimum rating and country
- Verify claimed handles against live profile data
- Build talent dashboards by rank and contribution
- Run periodic talent pool refreshes on a schedule

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

#### 👨‍🏫 Coaching and training

- Build curated problem sets by tag and difficulty
- Track student progress against community solve rates
- Recommend next problems by topic gap analysis
- Compile contest archives for prep camps

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

#### 📊 Analytics and BI

- Leaderboard dashboards for community sites
- Rating distribution and country breakdown reports
- Tag-popularity studies of the problem archive
- Long-horizon participation and growth analysis

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

#### 🧑‍💻 Tooling and integrations

- Sync Codeforces metadata into your CRM or LMS
- Power Discord and Slack bots with live rating data
- Build judging or training platforms backed by the archive
- Cross-reference contest results with ICPC season data

</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 Codeforces Scraper

Drive this actor from your own stack with a few lines of code.

- Trigger runs from **Node.js** using the [Apify JavaScript client](https://docs.apify.com/api/client/js/)
- Trigger runs from **Python** using the [Apify Python client](https://docs.apify.com/api/client/python/)
- Read the [Apify REST API docs](https://docs.apify.com/api/v2) to call the actor over HTTP

Schedules let you re-pull the leaderboard daily, refresh a candidate handle list weekly, or watch a single user's rating in near real time.

***

### ❓ Frequently Asked Questions

#### 💰 Is there a cost to run this Actor?

The actor itself is free to use on Apify. You pay only for the platform compute and storage you consume during a run. New accounts come with $5 of starter credit, which covers many small runs.

#### 🔑 Do I need a Codeforces API key?

No. The actor uses public read-only endpoints that do not require a key or token. You only need a Codeforces account if you later want to submit problems or post on the forum yourself.

#### 👤 Which handles can I look up?

Any public Codeforces handle. Pass a list under `handles` in `users` mode. The actor batches the list in chunks of 100 to respect the API and complete large jobs in one run.

#### 🏷️ How do problem tags work?

Tags are official Codeforces topic labels like `dp`, `graphs`, `binary search`, `math`, `greedy`, `data structures`, `dfs and similar`, `trees`, and many more. Pass a list under `tags` in `problemset` mode to keep only problems that match every listed tag.

#### 🏟️ Does this include gym contests?

By default `gym` is `false`. Set it to `true` in `contests` mode to also include training (gym) contests in the result set.

#### 🤝 Can I use this Actor for commercial use?

Yes. Codeforces public API data is openly accessible and widely used in third-party tools. You are responsible for following the Codeforces terms of service and any local rules around recruiting and personal data.

#### 💳 Do I need a paid Apify plan?

A paid plan is not required. Free accounts can preview up to 10 rows per run. Paid plans unlock up to 1,000,000 rows per run plus larger storage and compute budgets.

#### 🆘 What if a run fails?

Open the run in the Apify console to inspect the log, the input, and any partial dataset. Network errors and upstream rate limits are surfaced as `error` items in the dataset rather than as silent crashes.

#### ⚖️ Is scraping this data legal?

Codeforces publishes the API for public consumption. This actor reads only the public endpoints with no login or token, so the data flow is the same one any browser or curl request would produce. Compliance with the source terms and local law remains your responsibility.

#### 🏔️ Can I get the global top 100 rated users?

Yes. Set `mode` to `ratedList`, optionally toggle `activeOnly`, and set `maxItems` to 100. The actor sorts by rating descending so you get the top of the ladder first.

#### 🔄 How fresh is the data?

Each run hits Codeforces live, so ratings, recently solved problem counts, and contest phases reflect the source at the moment of the request.

***

### 🔌 Integrate with any app

Stream results into the tools your team already uses.

- [**Make**](https://apify.com/integrations) - low-code automation across thousands of apps
- [**Zapier**](https://apify.com/integrations) - trigger and route data into 6,000+ services
- [**n8n**](https://apify.com/integrations) - self-hosted workflow runner with native Apify support
- [**Slack**](https://apify.com/integrations) - notifications when runs complete or hit anomalies
- [**Google Sheets**](https://apify.com/integrations) - one-click dataset to spreadsheet sync
- [**BigQuery and Snowflake**](https://apify.com/integrations) - warehouse loads via webhook or schedule

***

### 🔗 Recommended Actors

- [**🐙 GitHub Trending Scraper**](https://apify.com/parseforge/github-trending-scraper) - track trending repos by language and time window
- [**📦 NPM Packages Scraper**](https://apify.com/parseforge/npm-packages-scraper) - inspect Node.js package metadata and downloads
- [**🔎 CrossRef Scraper**](https://apify.com/parseforge/crossref-scraper) - pull peer-reviewed computer science research papers
- [**📚 Open Library Scraper**](https://apify.com/parseforge/open-library-scraper) - source competitive programming book metadata
- [**🌐 Wikidata Entity Search Scraper**](https://apify.com/parseforge/wikidata-entity-search-scraper) - enrich profiles with structured entity links

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data feeds across developer communities, education, and research.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and a human will reply within one business day.

***

> This Actor accesses publicly available data only. By using it you accept the responsibility to comply with the source's Terms of Service, rate limits, and applicable laws including data-protection regulations. The data is scraped on-demand from the upstream public API and is not cached or pre-stored by this Actor.

# Actor input Schema

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

What to scrape

## `handles` (type: `array`):

List of Codeforces handles to scrape

## `tags` (type: `array`):

Filter problems by tags (e.g. dp, graphs, math)

## `gym` (type: `boolean`):

Whether to include gym (training) contests

## `activeOnly` (type: `boolean`):

Only include users who participated recently

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

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

## Actor input object example

```json
{
  "mode": "users",
  "handles": [
    "tourist"
  ],
  "tags": [],
  "gym": false,
  "activeOnly": false,
  "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 = {
    "mode": "users",
    "handles": [
        "tourist"
    ],
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Codeforces Competitive Programming Scraper",
        "description": "Scrape Codeforces public API for user info, contest history, problem set, and submission stats. Get rating, rank, country, max rating, and 8000+ problems. No API key required.",
        "version": "0.0",
        "x-build-id": "T3OTIEpgZ8yPmAThy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~codeforces-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-codeforces-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~codeforces-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-codeforces-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~codeforces-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-codeforces-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "users",
                            "problemset",
                            "contests",
                            "ratedList"
                        ],
                        "type": "string",
                        "description": "What to scrape",
                        "default": "users"
                    },
                    "handles": {
                        "title": "Handles (for users mode)",
                        "type": "array",
                        "description": "List of Codeforces handles to scrape",
                        "default": [
                            "tourist"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tags": {
                        "title": "Problem tags (for problemset mode)",
                        "type": "array",
                        "description": "Filter problems by tags (e.g. dp, graphs, math)",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "gym": {
                        "title": "Include Gym contests (for contests mode)",
                        "type": "boolean",
                        "description": "Whether to include gym (training) contests",
                        "default": false
                    },
                    "activeOnly": {
                        "title": "Active rated users only (for ratedList mode)",
                        "type": "boolean",
                        "description": "Only include users who participated recently",
                        "default": false
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
