# Hockey Reference Scraper (`crawlerbros/hockey-reference-scraper`) Actor

Scrape Hockey Reference - the definitive source for NHL, WHA, and hockey statistics. Search players, get full career stats, browse team rosters, season statistical leaders, and NHL draft classes. No proxy or API key required.

- **URL**: https://apify.com/crawlerbros/hockey-reference-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## Hockey Reference Scraper

Extract NHL player stats, team rosters, season scoring leaders, draft picks, and player profiles from [hockey-reference.com](https://www.hockey-reference.com) — the definitive source for professional hockey statistics.

### What this actor does

- **Five modes:** `search`, `playerStats`, `teamSeason`, `seasonLeaders`, `draft`
- **Player search** — find any NHL player by name and get their profile links
- **Player stats** — career stats, bio, position, height/weight, nationality
- **Team rosters** — full season roster for any of 32 NHL teams
- **Season leaders** — top skaters or goalies for any NHL season (1990–2024)
- **Draft classes** — complete entry draft picks with amateur teams and NHL career stats
- **Filters** — narrow by position, nationality, with zero null fields in output

### Output fields

#### Player / Search records
| Field | Description |
|---|---|
| `playerId` | Hockey Reference player ID (e.g. `mcdavco01`) |
| `playerName` | Full name |
| `position` | C, LW, RW, D, or G |
| `team` | Last team played for |
| `league` | League (NHL, WHA, etc.) |
| `hallOfFame` | `true` if inducted |
| `playerUrl` | Canonical player page URL |

#### Skater stats records
| Field | Description |
|---|---|
| `playerName` | Player name |
| `age` | Age during season |
| `team` | Team abbreviation |
| `position` | Skating position |
| `gamesPlayed`, `goals`, `assists`, `points` | Core scoring stats |
| `plusMinus` | Plus/minus |
| `penaltyMins` | Penalty minutes |
| `shotsOnGoal`, `shotPercent` | Shot stats |
| `evenStrengthGoals`, `powerPlayGoals`, `shortHandedGoals`, `gameWinningGoals` | Goal breakdown |
| `evenStrengthAssists`, `powerPlayAssists` | Assist breakdown |
| `timeOnIce`, `avgTimeOnIce` | Ice time |
| `faceoffWins`, `faceoffLosses` | Faceoff stats |
| `season` | Season year |

#### Goalie stats records
| Field | Description |
|---|---|
| `playerName`, `age`, `team` | Identity |
| `gamesPlayed`, `gamesStarted` | Workload |
| `goalieWins`, `goalieLosses`, `goalieTiesOrOT` | Record |
| `goalsAgainst`, `shotsAgainst`, `saves` | Raw totals |
| `savePercentage`, `goalsAgainstAvg` | Rate stats |
| `goalieShutouts` | Shutouts |
| `minutesPlayed`, `qualityStarts` | Advanced |
| `season` | Season year |

#### Draft pick records
| Field | Description |
|---|---|
| `draftYear`, `pickOverall` | Draft position |
| `team` | Drafting team |
| `playerName`, `position`, `nationality` | Player info |
| `draftAge`, `amateurTeam` | Draft context |
| `nhlGamesPlayed`, `nhlGoals`, `nhlAssists`, `nhlPoints` | NHL career totals |
| `goalieWins`, `savePercentage`, `goalsAgainstAvg` | Goalie career stats |

#### Team roster records
| Field | Description |
|---|---|
| `jerseyNumber`, `playerName`, `position` | Core info |
| `age`, `height`, `weight`, `shoots` | Physical |
| `birthDate`, `nationality` | Bio |
| `yearsExperience`, `team`, `season` | Context |

All records include `recordType`, `sourceUrl`, `scrapedAt`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `playerStats` / `teamSeason` / `seasonLeaders` / `draft` |
| `searchQuery` | string | `Connor McDavid` | Player name (mode=search) |
| `playerIds` | array | – | Hockey Ref player IDs, e.g. `mcdavco01` (mode=playerStats) |
| `team` | select | `EDM` | NHL team abbreviation (mode=teamSeason) |
| `season` | integer | `2024` | Season end year 1990–2024 (modes: teamSeason, seasonLeaders) |
| `statType` | select | `skaters` | `skaters` or `goalies` (mode=seasonLeaders) |
| `draftYear` | integer | `2023` | Draft year 1963–2024 (mode=draft) |
| `position` | select | – | Filter by position: C, LW, RW, D, G |
| `nationality` | select | – | Filter by nationality code (CA, US, SE, FI, RU, ...) |
| `maxItems` | integer | `50` | Max records to emit (1–1000) |

### Example inputs

#### Search for a player
```json
{"mode": "search", "searchQuery": "Connor McDavid", "maxItems": 5}
````

#### Get season leaders

```json
{"mode": "seasonLeaders", "season": 2024, "statType": "skaters", "maxItems": 50}
```

#### Get a team's roster

```json
{"mode": "teamSeason", "team": "EDM", "season": 2024}
```

#### Get a draft class

```json
{"mode": "draft", "draftYear": 2023, "maxItems": 100}
```

#### Get player career stats

```json
{"mode": "playerStats", "playerIds": ["mcdavco01", "gretzwa01"]}
```

### Use cases

- **Fantasy hockey** — compare player stats, track scoring leaders by season
- **Sports analytics** — build historical datasets for player and team performance
- **Scouting databases** — track draft picks, amateur teams, career progression
- **Hockey journalism** — data-backed articles with verified stats
- **Historical research** — decade-by-decade scoring trends, nationality analysis
- **Team management tools** — roster depth charts with age, experience, stats

### FAQ

**What is Hockey Reference?**
Hockey Reference is operated by Sports Reference LLC and is the most comprehensive freely available source for NHL and international hockey statistics, covering every player and team since the NHL's founding.

**How often is the data updated?**
Hockey Reference updates during the season typically within hours of games finishing. Historical data is stable.

**What player ID format is used?**
Player IDs follow the pattern `firstfiveoflastname` + `firsttwoffirstname` + `01` (e.g. `mcdavco01` for Connor McDavid). You can find IDs in any player page URL on hockey-reference.com.

**What does the `season` field mean?**
The season end year — `2024` means the 2023–24 NHL season.

**Can I get data for seasons before 1990?**
The `season` input accepts values down to 1990. Historical data is available on the site going back further, but the actor's tested range is 1990–2024.

**What happens if a team abbreviation changed?**
The actor uses current team abbreviations (e.g. `ARI` for Arizona). Relocated franchises may have different historical slugs on the site.

**Are null fields included?**
No. The actor uses strict omit-empty logic — only fields with real data appear in output records.

# Actor input Schema

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

What to scrape. `search` finds players by name. `playerStats` fetches career stats for specific player IDs. `teamSeason` retrieves a team's season roster. `seasonLeaders` gets the top skaters or goalies for a season. `draft` returns the full entry draft class for a year.

## `searchQuery` (type: `string`):

Player name to search for (e.g. `Connor McDavid`, `Wayne Gretzky`).

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

Hockey Reference player IDs, e.g. `mcdavco01`, `gretzwa01`. Found in player page URLs.

## `team` (type: `string`):

NHL team abbreviation for `teamSeason` mode.

## `season` (type: `integer`):

NHL season end year (e.g. 2024 for the 2023-24 season).

## `statType` (type: `string`):

Whether to fetch skater or goalie leaders.

## `draftYear` (type: `integer`):

NHL Entry Draft year (e.g. 2023).

## `position` (type: `string`):

Only return records matching this position.

## `nationality` (type: `string`):

Only return records with this nationality code (e.g. `CA`, `US`, `SE`, `FI`, `RU`).

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

Maximum number of records to emit.

## `proxyConfiguration` (type: `object`):

Apify proxy configuration. Use AUTO datacenter proxy to avoid blocks.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Connor McDavid",
  "playerIds": [],
  "team": "EDM",
  "season": 2024,
  "statType": "skaters",
  "draftYear": 2023,
  "position": "",
  "nationality": "",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped hockey records (players, skaters, goalies, draft picks).

# 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": "search",
    "searchQuery": "Connor McDavid",
    "playerIds": [],
    "team": "EDM",
    "season": 2024,
    "statType": "skaters",
    "draftYear": 2023,
    "position": "",
    "nationality": "",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "search",
    "searchQuery": "Connor McDavid",
    "playerIds": [],
    "team": "EDM",
    "season": 2024,
    "statType": "skaters",
    "draftYear": 2023,
    "position": "",
    "nationality": "",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "search",
  "searchQuery": "Connor McDavid",
  "playerIds": [],
  "team": "EDM",
  "season": 2024,
  "statType": "skaters",
  "draftYear": 2023,
  "position": "",
  "nationality": "",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/hockey-reference-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hockey Reference Scraper",
        "description": "Scrape Hockey Reference - the definitive source for NHL, WHA, and hockey statistics. Search players, get full career stats, browse team rosters, season statistical leaders, and NHL draft classes. No proxy or API key required.",
        "version": "1.0",
        "x-build-id": "beUeF83cClsZdnyy0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~hockey-reference-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~hockey-reference-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~hockey-reference-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "playerStats",
                            "teamSeason",
                            "seasonLeaders",
                            "draft"
                        ],
                        "type": "string",
                        "description": "What to scrape. `search` finds players by name. `playerStats` fetches career stats for specific player IDs. `teamSeason` retrieves a team's season roster. `seasonLeaders` gets the top skaters or goalies for a season. `draft` returns the full entry draft class for a year.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Player name to search for (e.g. `Connor McDavid`, `Wayne Gretzky`).",
                        "default": "Connor McDavid"
                    },
                    "playerIds": {
                        "title": "Player IDs (mode=playerStats)",
                        "type": "array",
                        "description": "Hockey Reference player IDs, e.g. `mcdavco01`, `gretzwa01`. Found in player page URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "team": {
                        "title": "Team (mode=teamSeason)",
                        "enum": [
                            "ANA",
                            "ARI",
                            "BOS",
                            "BUF",
                            "CGY",
                            "CAR",
                            "CHI",
                            "COL",
                            "CBJ",
                            "DAL",
                            "DET",
                            "EDM",
                            "FLA",
                            "LAK",
                            "MIN",
                            "MTL",
                            "NSH",
                            "NJD",
                            "NYI",
                            "NYR",
                            "OTT",
                            "PHI",
                            "PIT",
                            "SJS",
                            "SEA",
                            "STL",
                            "TBL",
                            "TOR",
                            "VAN",
                            "VGK",
                            "WSH",
                            "WPG"
                        ],
                        "type": "string",
                        "description": "NHL team abbreviation for `teamSeason` mode.",
                        "default": "EDM"
                    },
                    "season": {
                        "title": "Season year (modes: teamSeason, seasonLeaders)",
                        "minimum": 1990,
                        "maximum": 2024,
                        "type": "integer",
                        "description": "NHL season end year (e.g. 2024 for the 2023-24 season).",
                        "default": 2024
                    },
                    "statType": {
                        "title": "Stat type (mode=seasonLeaders)",
                        "enum": [
                            "skaters",
                            "goalies"
                        ],
                        "type": "string",
                        "description": "Whether to fetch skater or goalie leaders.",
                        "default": "skaters"
                    },
                    "draftYear": {
                        "title": "Draft year (mode=draft)",
                        "minimum": 1963,
                        "maximum": 2024,
                        "type": "integer",
                        "description": "NHL Entry Draft year (e.g. 2023).",
                        "default": 2023
                    },
                    "position": {
                        "title": "Filter by position",
                        "enum": [
                            "",
                            "C",
                            "LW",
                            "RW",
                            "D",
                            "G"
                        ],
                        "type": "string",
                        "description": "Only return records matching this position.",
                        "default": ""
                    },
                    "nationality": {
                        "title": "Filter by nationality (ISO 3166-1 alpha-2)",
                        "enum": [
                            "",
                            "CA",
                            "US",
                            "SE",
                            "FI",
                            "RU",
                            "CZ",
                            "SK",
                            "CH",
                            "DE",
                            "NO",
                            "DK",
                            "LV",
                            "AU",
                            "BY",
                            "SI"
                        ],
                        "type": "string",
                        "description": "Only return records with this nationality code (e.g. `CA`, `US`, `SE`, `FI`, `RU`).",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of records to emit.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Use AUTO datacenter proxy to avoid blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
