# ESPN Rosters & Player Stats (`crawlerbros/espn-rosters-player-stats`) Actor

Scrape team rosters and player career statistics from ESPN across 16 leagues and 5 sports. No account or proxy required.

- **URL**: https://apify.com/crawlerbros/espn-rosters-player-stats.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** News, SEO tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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

## ESPN Rosters & Player Stats Scraper

Scrape team rosters and player career statistics from [ESPN](https://www.espn.com) — no account or subscription required. Supports 16 leagues across 5 sports including the NBA, NFL, MLB, NHL, MLS, WNBA, NCAA basketball and football, Premier League, La Liga, Champions League, Bundesliga, Serie A, Ligue 1, and Liga MX.

### What This Scraper Does

This actor fetches team rosters from ESPN's public JSON API and returns one flat record per player with bio fields (name, jersey, position, height, weight, date of birth, college, etc.). With **Fetch Player Career Stats** enabled, it also adds sport-specific career totals — points, rebounds, passing yards, goals, etc. Supports current and historical seasons.

### Supported Leagues

| Code | Sport | League |
|---|---|---|
| `nba` | Basketball | NBA |
| `wnba` | Basketball | WNBA |
| `ncaam` | Basketball | NCAA Men's |
| `ncaaw` | Basketball | NCAA Women's |
| `nfl` | Football | NFL |
| `ncaaf` | Football | NCAA Football |
| `mlb` | Baseball | MLB |
| `nhl` | Hockey | NHL |
| `mls` | Soccer | Major League Soccer |
| `epl` | Soccer | English Premier League |
| `laliga` | Soccer | La Liga (Spain) |
| `ucl` | Soccer | UEFA Champions League |
| `bundesliga` | Soccer | Bundesliga (Germany) |
| `seriea` | Soccer | Serie A (Italy) |
| `ligue1` | Soccer | Ligue 1 (France) |
| `ligamx` | Soccer | Liga MX (Mexico) |

### Input

| Field | Type | Description |
|---|---|---|
| **Leagues** | List of strings | League codes to scrape. Defaults to `["nba"]`. |
| **Teams** | List of strings (optional) | Filter by team abbreviation (case-insensitive, e.g. `"LAL"`) or ESPN numeric team ID (e.g. `"13"`). Omit for all teams. |
| **Season** | Integer (optional) | Year the season ends (e.g. `2026` for NBA 2025-26). Omit for current season. |
| **Fetch Player Career Stats** | Boolean | If true, fetches career totals per player. Adds one API call per player (slow for large leagues). Default: `false`. |
| **Max Items** | Integer | Maximum number of player records across all leagues (1–50,000). Default: 500. |

#### Team Filter Examples
- Just Lakers and Celtics: `"teams": ["LAL", "BOS"]`
- By ID: `"teams": ["13", "2"]`
- Mixed: `"teams": ["LAL", "17"]`
- Unknown entries log a warning and are skipped.

#### Season Encoding

Use the ending year for cross-year seasons:
- NBA 2025-26 → `season: 2026`
- EPL 2025-26 → `season: 2026`
- NFL 2025 → `season: 2025`
- MLB 2025 → `season: 2025`

Historical support varies by sport. ESPN's public API typically returns the **current roster** even when a past season is requested; historical rosters are sparsely available for most leagues. Invalid or unavailable seasons are silently skipped (empty result, no error). If you need past-season rosters, verify availability on ESPN's website for your specific league + season before running.

### Output

Each record represents one player. Fields marked `?` are optional and appear only when ESPN returns data for them.

#### Core bio fields

| Field | Type | Description |
|---|---|---|
| `league` | string | League code e.g. `"nba"` |
| `sport` | string | e.g. `"basketball"` |
| `season` | integer? | Season year (when provided) |
| `teamId` | string | ESPN team ID |
| `teamName` | string | Full team name |
| `teamAbbreviation` | string? | e.g. `"LAL"` |
| `teamLogo` | string? | Logo URL |
| `playerId` | string | ESPN athlete ID |
| `firstName` | string? | |
| `lastName` | string? | |
| `fullName` | string | |
| `displayName` | string? | |
| `shortName` | string? | |
| `jersey` | string? | |
| `position` | string? | e.g. `"Small Forward"` |
| `positionAbbreviation` | string? | e.g. `"SF"` |
| `height` | integer? | Inches |
| `displayHeight` | string? | e.g. `"6' 9\""` |
| `weight` | integer? | Pounds |
| `displayWeight` | string? | e.g. `"250 lbs"` |
| `age` | integer? | |
| `dateOfBirth` | string? | ISO date |
| `birthPlace` | string? | e.g. `"Akron, Ohio"` |
| `debutYear` | integer? | First pro year |
| `experience` | integer? | Years in league |
| `college` | string? | For NBA/NFL/NCAA |
| `headshot` | string? | Headshot URL |
| `status` | string? | e.g. `"Active"` |
| `statsUrl` | string? | Link to ESPN stats page |
| `scrapedAt` | string | ISO 8601 UTC |

#### Career stats fields (when Fetch Player Career Stats is enabled)

Sport-specific fields are added to the same record:

**Basketball (NBA, WNBA, NCAAM/W):** `gamesPlayed`, `points`, `rebounds`, `assists`, `steals`, `blocks`, `fieldGoalPct`, `threePointPct`, `freeThrowPct`, `minutes`, `turnovers`

**Football (NFL, NCAAF):** `gamesPlayed`, `passingYards`, `passingTouchdowns`, `interceptions`, `passerRating`, `rushingYards`, `rushingTouchdowns`, `receptions`, `receivingYards`, `receivingTouchdowns`, `tackles`, `sacks`

**Baseball (MLB):** `gamesPlayed`, `battingAverage`, `homeRuns`, `rbis`, `hits`, `runs`, `stolenBases`, `era`, `wins`, `losses`, `strikeouts`, `inningsPitched`

**Hockey (NHL):** `gamesPlayed`, `goals`, `assists`, `points`, `plusMinus`, `penaltyMinutes`, `shotsOnGoal`, `savePct`, `goalsAgainstAverage`

**Soccer:** `appearances`, `goals`, `assists`, `minutesPlayed`, `yellowCards`, `redCards`, `shotsOnTarget`, `shots`

Fields only appear when ESPN returns data — no nulls.

#### Error Records

If a league's team list or a team's roster fails to fetch, an error record is emitted:

| Field | Description |
|---|---|
| `inputLeague` | League code attempted |
| `inputTeam` | Team (if applicable) |
| `inputSeason` | Season attempted |
| `error` | Human-readable message |
| `scrapedAt` | Timestamp |

### Frequently Asked Questions

**Do I need an ESPN account?**
No. This scraper only uses ESPN's public JSON API.

**Is a proxy required?**
No. ESPN's public API has no bot protection for typical use.

**How do I get a single player?**
Use the Teams filter to narrow to the player's team, then filter the output by `fullName` in your downstream pipeline. ESPN doesn't have a public name-search endpoint, but rosters are small so this is fast.

**Why is NCAA slow?**
NCAA basketball has 365 teams and NCAA football has 136. Pulling all rosters can return thousands of players. Use the Teams filter (e.g. `["DUKE", "KY"]`) to narrow. With Fetch Player Career Stats enabled, each player adds one more API call — for NCAA, the Teams filter is strongly recommended.

**Why are some stat fields missing?**
ESPN returns different stats per sport and per player role. For example, a defensive back won't have `passingYards`; a reliever may not have `wins`. Per the no-null rule, fields only appear when ESPN has data.

**What's the difference between this actor and the other ESPN actors?**
- **Scores & Schedules** returns game-by-game data (final scores, schedules, leaders).
- **Standings** returns team-level standings (W/L, rank, points).
- **Rosters & Player Stats** returns player-level data (who is on each team + career stats).

**Does ESPN return salary data?**
No. ESPN's public API does not expose salary information.

**Can I combine multiple leagues in one run?**
Yes. Pass multiple codes in `leagues`, e.g. `["nba", "nfl", "mlb"]`. Each record is tagged with its league.

**How often is roster data updated?**
ESPN updates rosters in near real-time as transactions happen. Running the actor returns the latest state at fetch time.

# Actor input Schema

## `leagues` (type: `array`):

League codes to scrape. Supported: nba, nfl, mlb, nhl, mls, wnba, ncaam, ncaaw, ncaaf, epl, laliga, ucl, bundesliga, seriea, ligue1, ligamx.
## `teams` (type: `array`):

Optional filter by team abbreviation (case-insensitive, e.g. 'LAL') or ESPN numeric team ID. Omit to fetch all teams in the selected leagues.
## `season` (type: `integer`):

Year the season ends (e.g. 2026 for NBA 2025-26). Leave empty for current season.
## `fetchPlayerStats` (type: `boolean`):

If enabled, makes one extra API call per player to fetch career statistics (points, rebounds, assists, goals, tackles, etc. depending on sport). Significantly slower for large leagues.
## `maxItems` (type: `integer`):

Maximum number of player records to return across all leagues (1–50,000).

## Actor input object example

```json
{
  "leagues": [
    "nba"
  ],
  "fetchPlayerStats": false,
  "maxItems": 500
}
````

# 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 = {
    "leagues": [
        "nba"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/espn-rosters-player-stats").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 = { "leagues": ["nba"] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/espn-rosters-player-stats").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 '{
  "leagues": [
    "nba"
  ]
}' |
apify call crawlerbros/espn-rosters-player-stats --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ESPN Rosters & Player Stats",
        "description": "Scrape team rosters and player career statistics from ESPN across 16 leagues and 5 sports. No account or proxy required.",
        "version": "0.0",
        "x-build-id": "Qxzo6P7JOQVKCkFcQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~espn-rosters-player-stats/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-espn-rosters-player-stats",
                "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~espn-rosters-player-stats/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-espn-rosters-player-stats",
                "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~espn-rosters-player-stats/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-espn-rosters-player-stats",
                "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": [
                    "leagues"
                ],
                "properties": {
                    "leagues": {
                        "title": "Leagues",
                        "type": "array",
                        "description": "League codes to scrape. Supported: nba, nfl, mlb, nhl, mls, wnba, ncaam, ncaaw, ncaaf, epl, laliga, ucl, bundesliga, seriea, ligue1, ligamx.",
                        "default": [
                            "nba"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "teams": {
                        "title": "Teams (optional)",
                        "type": "array",
                        "description": "Optional filter by team abbreviation (case-insensitive, e.g. 'LAL') or ESPN numeric team ID. Omit to fetch all teams in the selected leagues.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "season": {
                        "title": "Season (optional)",
                        "minimum": 1990,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Year the season ends (e.g. 2026 for NBA 2025-26). Leave empty for current season."
                    },
                    "fetchPlayerStats": {
                        "title": "Fetch Player Career Stats",
                        "type": "boolean",
                        "description": "If enabled, makes one extra API call per player to fetch career statistics (points, rebounds, assists, goals, tackles, etc. depending on sport). Significantly slower for large leagues.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of player records to return across all leagues (1–50,000).",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
