# NHL Stats Scraper (`parseforge/nhl-stats-scraper`) Actor

Scrape NHL data from the official NHL Web API - standings, schedules, team stats, rosters, and player profiles. No API key required.

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

## Pricing

from $25.88 / 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/main/banners/banner-default.jpg?raw=true)

## 🏒 NHL Stats Scraper

> 🚀 **Export official NHL data in seconds.** Pull the current 32-team standings, full schedules, club season stats, current rosters, and player landing pages from the official NHL data feed. No sign-up, no manual scraping, no setup.

> 🕒 **Last updated:** 2026-05-15 · **📊 25+ fields** per record · **🏒 All 32 NHL teams** · **🏆 Regular / Preseason / Postseason** · **🥅 Standings + Schedule + Rosters + Player landing**

The **NHL Stats Scraper** exports official National Hockey League data and returns up to **25+ structured fields per record**, including team abbreviation + name, conference + division, games played / wins / losses / OT losses, points and point percentage, regulation wins, goal differential, home / away / last-10 records, current streak, league sequence, official team logo, and a public deep-link to NHL.com.

The Actor covers **all 32 NHL teams, the full season schedule by date, club season stats by team and season, current rosters with bio data, and individual player landing pages** with career totals, featured stats, draft details, headshots, and hero images. Filter by team, season, or season type (Regular / Preseason / Postseason) to pull only what you need.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports media, fantasy-hockey apps, betting analytics teams, fan-engagement platforms, indie sports devs, hockey researchers | Live standings, schedule feeds, roster lookups, player profile dashboards, season-stat exports, content automation |

---

### 📋 What the NHL Stats Scraper does

Five lookup modes in a single run:

- 🏆 **Standings.** Current 32-team league standings with conference + division grouping, point totals, regulation wins, goal differential, home / away / last-10 records, and streaks.
- 📅 **Schedule.** Games on a chosen date (defaults to today). Filter by season type: `R` (Regular), `PR` (Preseason), `PO` (Postseason).
- 📊 **Team Stats.** Club season stats for one or many teams (skaters and goalies merged) for a chosen season code.
- 👤 **Player.** Player landing page for one or many player IDs, with sweater number, position, height, weight, birth info, draft details, headshot, hero image, career totals, and featured stats.
- 📋 **Roster.** Current roster for one or many teams, grouped by forward / defenseman / goalie with bio fields.

Each standings record includes the canonical NHL identifiers, team logo URL, official metrics from the live feed, and a direct link to the team page.

> 💡 **Why it matters:** hockey moves fast, and accurate standings and roster data underpin every fantasy product, betting model, and fan-facing dashboard. Building your own pipeline means juggling NHL's data feed, normalising IDs across season types, and refreshing for every game day.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>mode</code></td><td>string</td><td><code>"standings"</code></td><td>One of <code>standings</code>, <code>schedule</code>, <code>teamStats</code>, <code>player</code>, <code>roster</code>.</td></tr>
<tr><td><code>date</code></td><td>string</td><td><code>today</code></td><td>YYYY-MM-DD. Used in schedule mode.</td></tr>
<tr><td><code>teamAbbrev</code></td><td>string</td><td><code>none</code></td><td>Three-letter team code (32-team enum, e.g. <code>EDM</code>, <code>TOR</code>, <code>NYR</code>).</td></tr>
<tr><td><code>teamAbbrevs</code></td><td>array</td><td><code>[]</code></td><td>Batch lookup. Takes precedence over <code>teamAbbrev</code>.</td></tr>
<tr><td><code>season</code></td><td>string</td><td><code>""</code></td><td>Eight-digit season code (e.g. <code>20242025</code>) for teamStats mode.</td></tr>
<tr><td><code>playerId</code></td><td>string</td><td><code>""</code></td><td>NHL player ID for player mode (e.g. <code>8478402</code> = Connor McDavid).</td></tr>
<tr><td><code>playerIds</code></td><td>array</td><td><code>[]</code></td><td>Batch player landing lookup.</td></tr>
<tr><td><code>seasonType</code></td><td>string</td><td><code>""</code></td><td>Filter schedule: <code>R</code> = Regular, <code>PR</code> = Preseason, <code>PO</code> = Postseason.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: current 32-team standings.**

```json
{
    "mode": "standings",
    "maxItems": 32
}
````

**Example: Connor McDavid landing page.**

```json
{
    "mode": "player",
    "playerId": "8478402"
}
```

> ⚠️ **Good to Know:** the `season` input uses the eight-digit NHL season code format. For the 2024-2025 season, use `20242025`. Same goes for past seasons (`20232024`, `20222023`, etc.).

***

### 📊 Output

Each standings record contains **25+ fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema (standings mode)

| Field | Type | Example |
|---|---|---|
| 🏷️ `teamAbbrev` | string | `"EDM"` |
| 🏒 `teamName` | string | `"Edmonton Oilers"` |
| 🌎 `conferenceName` | string | `"Western"` |
| 🏆 `divisionName` | string | `"Pacific"` |
| 🎮 `gamesPlayed` | number | `60` |
| 🏅 `wins` | number | `38` |
| ❌ `losses` | number | `18` |
| ⏱️ `otLosses` | number | `4` |
| 📋 `recordSummary` | string | `"38-18-4"` |
| 🎯 `points` | number | `80` |
| 📊 `pointPctg` | number | `0.667` |
| 🥇 `regulationWins` | number | `30` |
| ⚖️ `goalDifferential` | number | `45` |
| ⚽ `goalFor` | number | `220` |
| 🥅 `goalAgainst` | number | `175` |
| 🏠 `homeRecord` | string | `"22-7-2"` |
| 🛫 `awayRecord` | string | `"16-11-2"` |
| 🔟 `last10Record` | string | `"7-2-1"` |
| 🔥 `streakCode` | string | `"W"` |
| 🔢 `streakCount` | number | `3` |
| 🔢 `leagueSequence` | number | `1` |
| 🖼️ `logo` | string | `"https://assets.nhle.com/logos/nhl/svg/EDM_light.svg"` |
| 🔗 `url` | string | `"https://www.nhl.com/edm"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |

#### 📦 Sample record

<details>
<summary><strong>🏒 Standings: Edmonton Oilers</strong></summary>

```json
{
    "teamAbbrev": "EDM",
    "teamName": "Edmonton Oilers",
    "conferenceName": "Western",
    "divisionName": "Pacific",
    "gamesPlayed": 60,
    "wins": 38,
    "losses": 18,
    "otLosses": 4,
    "recordSummary": "38-18-4",
    "points": 80,
    "pointPctg": 0.667,
    "regulationWins": 30,
    "goalDifferential": 45,
    "goalFor": 220,
    "goalAgainst": 175,
    "homeRecord": "22-7-2",
    "awayRecord": "16-11-2",
    "last10Record": "7-2-1",
    "streakCode": "W",
    "streakCount": 3,
    "leagueSequence": 1,
    "logo": "https://assets.nhle.com/logos/nhl/svg/EDM_light.svg",
    "url": "https://www.nhl.com/edm",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏒 | **Full league.** All 32 NHL teams across both conferences and four divisions, with logos and current standings. |
| 📅 | **Daily schedule.** Every game on any date, filtered by Regular / Preseason / Postseason. |
| 📊 | **Club season stats.** Skater and goalie stats merged with `playerId`, `firstName`, `lastName`, position, plus core counting stats. |
| 👤 | **Player landings.** Bio + draft + headshot + hero image + career totals + featured stats per player. |
| 📋 | **Current rosters.** Forward / defenseman / goalie groups with bio fields and headshots. |
| 🔁 | **Always fresh.** Each run pulls live data, so standings and rosters reflect the current state. |
| 🚫 | **No sign-up.** Works against the official NHL public feed. No login or token required. |

> 📊 Reliable NHL data is the foundation of every fantasy product, betting model, and fan-facing dashboard.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ NHL Stats Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **32 teams**, 5 modes, all season types | **Live per run** | mode, team, season, season type | ⚡ 2 min |
| Commercial sports data vendors | $$$$/month | Full + extras | Streaming | Many | ⏳ Weeks |
| Manual stats-page scraping | Free | Inconsistent | On demand | None | 🐢 Days |
| Free hockey widgets | Free | Display-only | Live | Limited | 🕒 No raw data |

Pick this Actor when you want structured records, all 32 teams, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the NHL Stats Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode, fill the relevant inputs (team abbreviation, season, or player ID), and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
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">

#### 📺 Sports Media & Publishing

- Daily NHL standings widgets on news sites
- Auto-generated game previews with rosters
- Postseason bracket dashboards with live results
- Push breaking news on hat tricks and shutouts

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

#### 🎲 Fantasy & Betting Analytics

- Pre-game roster checks and injury watch
- Live in-play model inputs from team stats
- Backtest strategies against full schedule history
- Postseason-only filters for derivatives markets

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

#### 🏟️ Fan-Engagement Apps

- "My team" alerts and push notifications
- Player stat cards in fan apps and Discord bots
- Standings leaderboards for fan communities
- Headshot + hero image galleries for fan-customisation widgets

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

#### 📊 Analytics & Research

- Build advanced-metrics dashboards with raw stats
- Train models on schedule + outcome metadata
- Cross-reference player IDs across multiple feeds
- Time-series studies on home / away / streak performance

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

***

### 🔌 Automating NHL Stats 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 documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Refresh standings every minute, daily roster snapshots, or weekly season-stat pulls are all one click.

***

### 🌟 Beyond business use cases

Hockey data powers more than commercial products. The same records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Sport-analytics coursework with real season data
- Statistical studies on home advantage and travel
- Sport-history dissertations grounded in live records
- Reproducible research pulls with cited timestamps

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

#### 🎨 Personal and creative

- Hobbyist team tracker dashboards
- Discord bots for fan communities
- Trading-card generators with current rosters
- Side projects and fan portfolios

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

#### 🤝 Non-profit and civic

- Youth-hockey league dashboards
- Sport-journalism for local newsrooms
- Inclusion analyses across rosters and birth countries
- Open-data hackathons on hockey culture

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

#### 🧪 Experimentation

- Train win-probability ML models with live standings
- Prototype agent pipelines that resolve player IDs
- Validate fan-product hypotheses with real fixture data
- Test live-stream UX concepts with real game 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%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%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%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%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?

Pick a mode (`standings`, `schedule`, `teamStats`, `player`, or `roster`), supply the relevant inputs, and click Start. The Actor pulls fresh records from the official NHL feed and emits a clean structured row per team, game, or player.

#### 🏒 Which teams are supported?

All 32 NHL teams across the Eastern and Western conferences and the four divisions (Atlantic, Metropolitan, Central, Pacific).

#### 📅 Can I get postseason games only?

Yes. Set `seasonType` to `PO` (Postseason) and the Actor restricts the schedule to playoff games. `PR` covers Preseason and `R` covers the Regular Season.

#### 📊 How do I look up team season stats?

Set `mode` to `teamStats`, supply `teamAbbrev` (or batch with `teamAbbrevs`), and set `season` to the eight-digit season code (e.g. `20242025`). The Actor returns merged skater + goalie stats with positions and counting metrics.

#### 👤 Can I pull individual player landing pages?

Yes. Set `mode` to `player` and supply `playerId` (e.g. `8478402` for Connor McDavid). Use `playerIds` for batch lookups (up to 100 per call).

#### 🖼️ Do I get team logos and player headshots?

Yes. Standings include direct `logo` URLs and player landings include `headshot` and `heroImage` URLs ready to embed.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor every minute, hourly, or daily. The dataset always reflects the current state of the live feed.

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

Only publicly available scoreboard data is collected. Review the NHL's terms of use for your specific use case, particularly if you redistribute or commercialise the content.

#### 💳 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 unlocks scheduling and higher concurrency.

#### 🔁 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

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
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get score updates in your channels
- [**n8n**](https://docs.apify.com/platform/integrations/n8n) - Self-hosted workflow automation
- [**Pipedream**](https://docs.apify.com/platform/integrations/pipedream) - Event-driven serverless workflows
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe hockey data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**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 standings into your product backend, or alert your fans in Slack when their team scores.

***

### 🔗 Recommended Actors

- [**⚾ MLB Stats Scraper**](https://apify.com/parseforge/mlb-stats-scraper) - Schedules, teams, rosters, player stats, live game feeds
- [**🏆 Sofascore Live Events Scraper**](https://apify.com/parseforge/sofascore-live-scraper) - 13-sport live + scheduled events feed
- [**🥅 TheSportsDB Scraper**](https://apify.com/parseforge/thesportsdb-scraper) - Crowd-sourced sports database across leagues
- [**🛡️ CWE MITRE Scraper**](https://apify.com/parseforge/cwe-mitre-scraper) - Software weakness reference catalogue
- [**📊 OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport reference dataset

> 💡 **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.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the National Hockey League or any of its clubs. All trademarks mentioned are the property of their respective owners. Only publicly available scoreboard data is collected.

# Actor input Schema

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

What to fetch from the official NHL data feed. Default is 'standings' (current 32-team league standings).

## `date` (type: `string`):

Date for schedule mode. Defaults to today.

## `teamAbbrev` (type: `string`):

Three-letter team abbreviation for teamStats / roster modes.

## `teamAbbrevs` (type: `array`):

Array of three-letter NHL team abbreviations for batch lookup. Takes precedence over single teamAbbrev. Max 32 (one per team).

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

Eight-digit season code (e.g. 20242025) for teamStats mode.

## `playerId` (type: `string`):

NHL player ID for player mode (e.g. 8478402 = Connor McDavid). Numeric, accepted as string so copy-pasted IDs work.

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

Array of NHL player IDs for batch landing-page lookup. Takes precedence over single playerId. Max 100 per call.

## `seasonType` (type: `string`):

Filter schedule by season type. R = Regular season, PR = Preseason, PO = Postseason.

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

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

## Actor input object example

```json
{
  "mode": "standings",
  "teamAbbrevs": [],
  "playerIds": [],
  "seasonType": "",
  "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": "standings",
    "date": "",
    "season": "",
    "playerId": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nhl-stats-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": "standings",
    "date": "",
    "season": "",
    "playerId": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nhl-stats-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": "standings",
  "date": "",
  "season": "",
  "playerId": "",
  "maxItems": 10
}' |
apify call parseforge/nhl-stats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHL Stats Scraper",
        "description": "Scrape NHL data from the official NHL Web API - standings, schedules, team stats, rosters, and player profiles. No API key required.",
        "version": "0.0",
        "x-build-id": "6weO9Uz3wuBt4hOYF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nhl-stats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nhl-stats-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~nhl-stats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nhl-stats-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~nhl-stats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nhl-stats-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": [
                            "standings",
                            "schedule",
                            "teamStats",
                            "player",
                            "roster"
                        ],
                        "type": "string",
                        "description": "What to fetch from the official NHL data feed. Default is 'standings' (current 32-team league standings).",
                        "default": "standings"
                    },
                    "date": {
                        "title": "Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Date for schedule mode. Defaults to today."
                    },
                    "teamAbbrev": {
                        "title": "Team Abbreviation",
                        "enum": [
                            "ANA",
                            "BOS",
                            "BUF",
                            "CAR",
                            "CBJ",
                            "CGY",
                            "CHI",
                            "COL",
                            "DAL",
                            "DET",
                            "EDM",
                            "FLA",
                            "LAK",
                            "MIN",
                            "MTL",
                            "NJD",
                            "NSH",
                            "NYI",
                            "NYR",
                            "OTT",
                            "PHI",
                            "PIT",
                            "SEA",
                            "SJS",
                            "STL",
                            "TBL",
                            "TOR",
                            "UTA",
                            "VAN",
                            "VGK",
                            "WPG",
                            "WSH"
                        ],
                        "type": "string",
                        "description": "Three-letter team abbreviation for teamStats / roster modes."
                    },
                    "teamAbbrevs": {
                        "title": "Team Abbreviations (batch lookup, roster / teamStats modes)",
                        "type": "array",
                        "description": "Array of three-letter NHL team abbreviations for batch lookup. Takes precedence over single teamAbbrev. Max 32 (one per team).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Eight-digit season code (e.g. 20242025) for teamStats mode."
                    },
                    "playerId": {
                        "title": "Player ID",
                        "type": "string",
                        "description": "NHL player ID for player mode (e.g. 8478402 = Connor McDavid). Numeric, accepted as string so copy-pasted IDs work."
                    },
                    "playerIds": {
                        "title": "Player IDs (batch lookup, player mode)",
                        "type": "array",
                        "description": "Array of NHL player IDs for batch landing-page lookup. Takes precedence over single playerId. Max 100 per call.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "seasonType": {
                        "title": "Season Type (schedule mode)",
                        "enum": [
                            "",
                            "R",
                            "PR",
                            "PO"
                        ],
                        "type": "string",
                        "description": "Filter schedule by season type. R = Regular season, PR = Preseason, PO = Postseason.",
                        "default": ""
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
