# Hockey Reference Scraper | NHL Stats and History (`parseforge/hockey-reference-scraper`) Actor

Pull NHL player, team, and game data from Hockey Reference including box scores, season stats, advanced metrics, standings, awards, and historical records. Built for hockey analytics, fantasy NHL tools, betting models, and sports journalism workflows requiring deep data.

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

## Pricing

from $19.00 / 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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏒 Hockey Reference NHL Stats Scraper

> 🚀 **Export NHL player statistics in seconds.** Pull **skater and goalie stats** for any season from Hockey Reference - goals, assists, points, plus-minus, shooting percentage, game-winning goals, and more. No API key, no manual copy-paste, no stale CSVs.

> 🕒 **Last updated:** 2026-05-22 · **📊 13 fields** per skater record · **🏒 900+ players per season** · **🌎 All 32 NHL teams** · **📅 Historical seasons available**

The **Hockey Reference NHL Stats Scraper** extracts season statistics from hockey-reference.com - the most authoritative NHL historical database on the web, maintained by Sports Reference. Every record returns real-time data pulled directly from the source, including player identity, team, position, and the full statistical profile for skaters or goalies.

The scraper covers **every skater and goalie** who played in the NHL for any given season, sorted by points. Choose the 2023-24 season (enter `2024`), the Stanley Cup-winning 2022 Avalanche era, or go back to any modern season. Results are available as CSV, Excel, JSON, or XML in under two minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports analysts, fantasy hockey managers, data journalists, hockey coaches, ML researchers, betting analysts, sports media | Season leaderboards, player ranking, fantasy draft prep, historical trend analysis, coaching analytics, ML model training |

---

### 📋 What the Hockey Reference NHL Stats Scraper does

Two data workflows from a single run:

- 🏒 **Skater stats.** All skaters for any NHL season - goals, assists, points, plus-minus, penalty minutes, shots, shooting percentage, and game-winning goals.
- 🥅 **Goalie stats.** All goaltenders for any season - games played, wins, losses, OT losses, save percentage, goals against average, shutouts, shots against, and saves.

Each skater record includes the Hockey Reference player ID (e.g. `mcdavco01`) for cross-referencing with other Sports Reference databases, the team abbreviation, and the exact season year string.

> 💡 **Why it matters:** Hockey Reference is the gold standard for NHL statistics. Building your own scraper means fighting cookie banners, HTML comment blocks, and bot detection. This Actor handles all of that with residential proxy rotation and browser stealth, so you get clean structured data on the first click.

---

### 🎬 Full Demo

_🚧 Coming soon: a 2-minute walkthrough showing how to go from sign-up to a downloaded season dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>season</td><td>string</td><td>"2024"</td><td>NHL season end year. Enter "2024" for the 2023-24 season, "2023" for 2022-23, etc.</td></tr>
<tr><td>playerType</td><td>string</td><td>"skaters"</td><td>"skaters" or "goalies". Controls which stat table is scraped.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: Top 50 skaters from the 2023-24 season.**

```json
{
    "season": "2024",
    "playerType": "skaters",
    "maxItems": 50
}
````

**Example: All goalies from the 2022-23 season.**

```json
{
    "season": "2023",
    "playerType": "goalies",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Hockey Reference sorts skaters by points (descending) by default, so the top scorers appear first. `maxItems: 50` gives you the top 50 point producers for the season. For traded players, the scraper deduplicates by player ID and keeps only the totals row (labeled `2TM`, `3TM`, etc.), not the individual team splits.

***

### 📊 Output

#### 🧾 Skater Schema

Each skater record contains **13 fields**. Download as CSV, Excel, JSON, or XML.

| Field | Type | Example |
|---|---|---|
| 🏷️ `playerName` | string | `"Nikita Kucherov"` |
| 🆔 `playerId` | string | `"kucheni01"` |
| 🏒 `team` | string | `"TBL"` |
| 📍 `position` | string | `"RW"` |
| 🎮 `gamesPlayed` | integer | `81` |
| 🥅 `goals` | integer | `44` |
| 🎯 `assists` | integer | `100` |
| ⭐ `points` | integer | `144` |
| ➕ `plusMinus` | integer | `8` |
| ⏱️ `penaltyMinutes` | integer | `22` |
| 🎯 `shots` | integer | `306` |
| 📊 `shootingPct` | number | `14.4` |
| 🏆 `gameWinningGoals` | integer | `6` |
| 📅 `season` | string | `"2024"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T02:48:23.734Z"` |
| ❌ `error` | string | null | `null` |

#### 📦 Sample skater records

<details>
<summary><strong>🏒 2023-24 points leader: Nikita Kucherov (144 pts)</strong></summary>

```json
{
    "playerName": "Nikita Kucherov",
    "playerId": "kucheni01",
    "team": "TBL",
    "position": "RW",
    "gamesPlayed": 81,
    "goals": 44,
    "assists": 100,
    "points": 144,
    "plusMinus": 8,
    "penaltyMinutes": 22,
    "shots": 306,
    "shootingPct": 14.4,
    "gameWinningGoals": 6,
    "season": "2024",
    "scrapedAt": "2026-05-22T02:48:23.734Z",
    "error": null
}
```

</details>

<details>
<summary><strong>🏒 2nd overall: Nathan MacKinnon (140 pts)</strong></summary>

```json
{
    "playerName": "Nathan MacKinnon",
    "playerId": "mackina01",
    "team": "COL",
    "position": "C",
    "gamesPlayed": 82,
    "goals": 51,
    "assists": 89,
    "points": 140,
    "plusMinus": 35,
    "penaltyMinutes": 42,
    "shots": 405,
    "shootingPct": 12.6,
    "gameWinningGoals": 9,
    "season": "2024",
    "scrapedAt": "2026-05-22T02:48:23.734Z",
    "error": null
}
```

</details>

<details>
<summary><strong>🏒 3rd overall: Connor McDavid (132 pts)</strong></summary>

```json
{
    "playerName": "Connor McDavid",
    "playerId": "mcdavco01",
    "team": "EDM",
    "position": "C",
    "gamesPlayed": 76,
    "goals": 32,
    "assists": 100,
    "points": 132,
    "plusMinus": 35,
    "penaltyMinutes": 30,
    "shots": 263,
    "shootingPct": 12.2,
    "gameWinningGoals": 5,
    "season": "2024",
    "scrapedAt": "2026-05-22T02:48:23.734Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏒 | **All 900+ skaters per season.** Every player who dressed for an NHL game that year, not just stars. |
| 🥅 | **Goalie mode.** Switch to goalies for GAA, save percentage, shutouts, and wins. |
| 📅 | **Any season, any year.** Just change the season input - 1990s dynasties to the present. |
| 🆔 | **Sports Reference player IDs.** Cross-reference with baseball-reference.com, fbref.com, and the full Sports Reference network. |
| ⚡ | **Fast.** 10 players in under 20 seconds, 900+ full season in under 2 minutes. |
| 🛡️ | **Stealth.** Residential proxy + camoufox browser fingerprinting bypasses bot detection. |
| 🔁 | **Real-time.** Every run pulls live data. No cached snapshots, no stale CSVs. |

> 📊 Hockey Reference is cited by NHL front offices, national media, and betting models as the authoritative source for historical NHL statistics.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ Hockey Reference Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All 900+ players** per season | **Live per run** | ⚡ 2 min |
| NHL API (official) | Free | Current season only | Real-time | 🐢 Hours to parse |
| Manual copy-paste from hockey-reference.com | Free | Full history | Manual | 🕒 Hours per table |
| Commercial sports data APIs | $200+/month | Licensed | Delayed feed | ⏳ Days |

***

### 🚀 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 Hockey Reference NHL Stats Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick your season (e.g. `"2024"`), player type (`"skaters"` or `"goalies"`), and `maxItems`.
4. 🚀 **Run it.** Click **Start** and wait under 2 minutes.
5. 📥 **Download.** Grab your results from 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">

#### 🏒 Fantasy Hockey & Sports Betting

- Build pre-draft rankings with current shooting percentage and game-winning goals
- Track plus-minus trends across multiple seasons for handicapping
- Identify breakout candidates using shots and shooting percentage delta
- Automate weekly stat refreshes for live fantasy leagues

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

#### 📰 Sports Media & Journalism

- Pull top-10 scorers lists for articles without manual table exports
- Build season comparison graphics with consistent field names
- Track milestone races (goal 50, point 100) with live data
- Archive historical season leaders for longform features

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

#### 🤖 Machine Learning & Analytics

- Train player-performance prediction models with multi-season datasets
- Build clustering models to identify player archetypes by stat profile
- Cross-reference with salary data for efficiency models
- Feature engineering pipelines for expected-goals projections

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

#### 🏟️ Coaching & Front Office

- Evaluate opponents' top threats by points and shooting percentage
- Scout trade targets by position and plus-minus across recent seasons
- Build internal dashboards with auto-refreshed season stats
- Compare current roster to historical equivalents

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

***

### 🔌 Automating Hockey Reference 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. Set a weekly refresh at the start of each week during the NHL season to keep your database in sync with the latest stats.

***

### 🌟 Beyond business use cases

Structured NHL statistics power more than commercial workflows. The same dataset supports research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Hockey analytics research and peer-reviewed papers
- Sports economics studies correlating salary and performance
- Reproducible research with versioned season pulls
- Network analysis of NHL player movement and team composition

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

#### 🎨 Personal and creative

- Side projects and indie hockey analytics apps
- Personal fantasy hockey dashboards and draft tools
- Content research for hockey bloggers, podcasters, and creators
- Hobbyist stat databases and personal record-tracking

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

#### 🤝 Non-profit and civic

- Youth hockey program benchmarking against NHL benchmarks
- Journalism on player demographics, salaries, and diversity
- Open datasets for the hockey analytics community
- Academic support for sports science programs

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

#### 🧪 Experimentation

- Train point-prediction or WAR-equivalent ML models
- Validate new hockey metrics against official totals
- Prototype agent pipelines for automated sports commentary
- Test dashboard concepts with real season data

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

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Hockey%20Reference%20NHL%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Hockey%20Reference%20NHL%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Hockey%20Reference%20NHL%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Hockey%20Reference%20NHL%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter a season year and player type, click Start, and the Actor loads the Hockey Reference stats page using a stealth browser with residential proxy rotation. The stats table is parsed with cheerio and each row is emitted as a clean structured record. No captchas, no rate limits in normal use.

#### 📅 What seasons are available?

Any modern NHL season is available. Enter the end year of the season: `"2024"` for 2023-24, `"2023"` for 2022-23, and so on back to the early 1990s and beyond. Hockey Reference maintains records going back to the 1917-18 season.

#### 🔄 How are traded players handled?

Hockey Reference shows a totals row (labeled with the number of teams, e.g. `TBL`+`EDM` shows as the first row for that player) plus per-team rows. This Actor keeps only the first occurrence of each player ID, which is always the totals row, so traded players appear once with their full-season combined stats.

#### 🥅 Can I get goalie stats?

Yes. Set `playerType` to `"goalies"` and the Actor switches to the goalie stats table, returning wins, losses, OT losses, save percentage, GAA, shutouts, shots against, and saves.

#### ⏰ Can I schedule regular season refreshes?

Yes. Use Apify Schedules to run this Actor weekly during the NHL season. Set `maxItems` high (e.g. 1000) and the full skater leaderboard refreshes on your chosen cadence.

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

No. The free plan is enough to test (10 records per run). A paid plan lifts the limit, gives you scheduling, and lets you pull the full 900+ player roster per season.

#### 🔁 What happens if a run fails?

Inspect the log in the Runs tab on Apify Console. The most common cause is a proxy timeout - re-running usually succeeds. The Actor logs the exact URL it attempted, making diagnosis straightforward.

#### 📊 What fields are available for goalies?

Goalie records include: `playerName`, `playerId`, `team`, `position`, `gamesPlayed`, `wins`, `losses`, `otLosses`, `savePercentage`, `goalsAgainstAvg`, `shutouts`, `shotsAgainst`, `saves`, `season`, `scrapedAt`.

#### 🏒 Why are skaters sorted by points?

Hockey Reference's default sort is points descending. The scraper preserves this order. Set `maxItems` to 50 to get the top 50 scorers, or set it to 1000 to get the full roster sorted the same way.

#### 🆘 What if I need help?

Reach out via the contact form linked below. Include the season and player type that caused the issue, and attach the run log from Apify Console.

***

### 🔌 Integrate with any app

Hockey Reference NHL Stats 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 with NHL data
- [**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 stats into your data 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 player stats into your product backend, or alert your fantasy hockey league in Slack.

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [**⚽ FBref Scraper**](https://apify.com/parseforge/fbref-scraper) | Soccer stats from the Sports Reference network |
| [**🏟️ ESPN Sports Scraper**](https://apify.com/parseforge/espn-sports-scraper) | Standings and scores for NHL, NBA, NFL, MLB |
| [**🏈 Dick's Sporting Goods Scraper**](https://apify.com/parseforge/dicks-sporting-goods-scraper) | Sports equipment prices and availability |
| [**♟️ Chess.com Scraper**](https://apify.com/parseforge/chess-com-scraper) | Chess player profiles and game history |
| [**🎮 RAWG Video Games Scraper**](https://apify.com/parseforge/rawg-scraper) | Game data for sports titles and more |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-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.

***

*Data is sourced from hockey-reference.com for informational and research purposes. All statistics are the property of Sports Reference LLC. This Actor is not affiliated with, endorsed by, or sponsored by Sports Reference LLC or the NHL.*

# Actor input Schema

## `season` (type: `string`):

NHL season end year (e.g. '2024' for 2023-24 season, '2023' for 2022-23)

## `playerType` (type: `string`):

Type of player stats to retrieve

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

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

## Actor input object example

```json
{
  "season": "2024",
  "playerType": "skaters",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "season": "2024",
    "playerType": "skaters",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hockey-reference-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 = {
    "season": "2024",
    "playerType": "skaters",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hockey-reference-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 '{
  "season": "2024",
  "playerType": "skaters",
  "maxItems": 10
}' |
apify call parseforge/hockey-reference-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hockey Reference Scraper | NHL Stats and History",
        "description": "Pull NHL player, team, and game data from Hockey Reference including box scores, season stats, advanced metrics, standings, awards, and historical records. Built for hockey analytics, fantasy NHL tools, betting models, and sports journalism workflows requiring deep data.",
        "version": "0.1",
        "x-build-id": "se21llIZi9CZr7Z7f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hockey-reference-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hockey-reference-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~hockey-reference-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hockey-reference-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~hockey-reference-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hockey-reference-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": {
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "NHL season end year (e.g. '2024' for 2023-24 season, '2023' for 2022-23)",
                        "default": "2024"
                    },
                    "playerType": {
                        "title": "Player Type",
                        "enum": [
                            "skaters",
                            "goalies"
                        ],
                        "type": "string",
                        "description": "Type of player stats to retrieve",
                        "default": "skaters"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
