# ESPN Injury Report Scraper - NFL, NBA, MLB, NHL Injuries (`hgservices/espn-injury-report-scraper`) Actor

Scrape the ESPN injury report for the NFL, NBA, MLB, NHL, WNBA and college football. Get Out, Questionable, IR and IL players with injury type, expected return date and news. Export to JSON, CSV, Excel

- **URL**: https://apify.com/hgservices/espn-injury-report-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 injury report row saveds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ESPN Injury Report Scraper — NFL, NBA, MLB, NHL, WNBA Injuries

Get today's **ESPN injury report** for the **NFL, NBA, MLB, NHL, WNBA and college football** as clean, structured data. You get every player listed as **Out, Doubtful, Questionable, Day-To-Day, on Injured Reserve or on the MLB Injured List**. Each row has **the injury (body part, type and side)**, **the expected return date**, the **fantasy status** and the latest injury news.

Filter by league, team, player, position or status. Download the results as JSON, CSV or Excel, call the Actor from the API, or ask an AI assistant such as Claude or ChatGPT for injury updates. You do not need an ESPN account or an API key.

### What does ESPN Injury Report Scraper do?

It collects the current injury report for every team in the leagues you pick and returns one row per player. Each row tells you:

- **Who** — player name, ESPN player ID, position, team and headshot photo
- **Status** — Out, Doubtful, Questionable, Day-To-Day, Injured Reserve, 7/10/15/60-Day IL, Suspension and more, plus the fantasy designation (GTD, IR-R, PUP-R and others)
- **What** — the injury: body part (Knee, Hamstring, Ankle), type (Sprain, Fracture, Surgery) and side (Left, Right)
- **When back** — ESPN's expected return date
- **Why** — the latest news note and the full note with the outlook, and who wrote it (for example RotoWire)
- **When** — the date and time the report was posted, in UTC and US Eastern time

A run for all six leagues takes a few seconds.

### Who is it for?

- **Fantasy sports players** — check who is out or questionable before lineup lock, every day, without opening 32 team pages.
- **Sports bettors and betting model builders** — injuries move lines. Collect a daily snapshot and build an injury history for your models.
- **Sports media, newsletters and apps** — feed an injury table, a Slack or Discord alert, or a website widget.
- **Analysts and researchers** — study injury rates by team, position, body part or season.

### Supported leagues

| League | Code | Typical players on the report |
|--------|------|-------------------------------|
| NFL | `nfl` | ~200 injured, plus ~600 news notes on healthy players |
| MLB | `mlb` | ~290 |
| NHL | `nhl` | ~70–110 |
| NBA | `nba` | ~60–80 |
| WNBA | `wnba` | ~50 |
| NCAA Football (college football) | `ncaaf` | a handful |

ESPN does not publish injury reports for college basketball or soccer, so those leagues are not offered. Report sizes change with the season. For example, the NBA report is short in the off-season and grows during the season.

### How to get an ESPN injury report

1. Open the Actor and pick one or more **leagues**.
2. Optionally, choose an **injury status** (for example only "Out"), or filter by **team**, **player** or **position**.
3. Click **Start**.
4. Open the **Output** tab to see the table, or export the data as JSON, CSV, Excel, XML or HTML.

To keep your data current, create a **schedule** (for example every morning at 9 AM) and connect it to Google Sheets, Slack, a webhook or your database.

### Input

| Field | What it does | Example |
|-------|--------------|---------|
| **Leagues** | Leagues to get injury reports for (at least one) | `["nfl", "nba"]` |
| **Injury status** | Only these statuses. Leave empty for every player who is hurt, sick, suspended or on leave | `["Out", "Injured Reserve"]` |
| **Teams** | Team abbreviation or name | `["KC"]`, `["Chiefs"]`, `["Los Angeles Lakers"]` |
| **Player names** | Part of a player's name | `["mahomes"]`, `["LeBron James"]` |
| **Positions** | Position abbreviation or name | `["QB", "WR"]`, `["Pitcher"]` |
| **Only reports from the last N days** | Drop older reports (1–365) | `7` |

The text filters ignore upper and lower case and accents, so `Dončić` finds `Doncic` and `Montréal` finds `Montreal Canadiens`. If a team or player in your filter is not on today's report, the run log and the run status tell you.

#### Injury status options

| Option | Covers | Leagues |
|--------|--------|---------|
| Out | Will not play | All |
| Doubtful | Unlikely to play | NFL |
| Questionable | Uncertain to play | NFL |
| Day-To-Day | Short-term injury, status checked daily | NBA, NHL, MLB |
| Injured Reserve | NFL and NHL injured reserve, and the MLB 7-, 10-, 15- and 60-Day Injured List | NFL, NHL, MLB |
| Suspension | Suspended by the league | MLB, NHL |
| Personal Leave | Paternity or bereavement leave | MLB |
| Active | Healthy player with a news note | NFL, NCAAF |

**Tip:** ESPN also posts news notes on healthy players (status "Active"). By default they are not included, so you get only real injuries. Select "Active" when you want the latest news on a specific player, healthy or not.

#### Example: today's NFL injury report

```json
{
  "leagues": ["nfl"]
}
```

#### Example: every player ruled out or on IR/IL in the four major leagues

```json
{
  "leagues": ["nfl", "nba", "mlb", "nhl"],
  "injuryStatuses": ["Out", "Injured Reserve"]
}
```

#### Example: injured quarterbacks and wide receivers on two teams

```json
{
  "leagues": ["nfl"],
  "teams": ["Chiefs", "SF"],
  "positions": ["QB", "WR"]
}
```

#### Example: all news on one player, injured or not

```json
{
  "leagues": ["nfl"],
  "players": ["mahomes"],
  "injuryStatuses": ["Out", "Doubtful", "Questionable", "Injured Reserve", "Active"]
}
```

### Output

You get one row per player on the injury report, newest report first. This is a real row from an NBA run:

```json
{
  "recordType": "injury",
  "league": "nba",
  "leagueName": "NBA",
  "sport": "basketball",
  "season": { "year": 2027, "type": 1, "typeName": "Preseason", "displayName": "2026-27" },
  "team": { "id": "29", "name": "Memphis Grizzlies", "abbreviation": "MEM" },
  "player": {
    "id": "4600663",
    "name": "Zach Edey",
    "shortName": "Z. Edey",
    "position": "Center",
    "positionAbbreviation": "C",
    "headshot": "https://a.espncdn.com/i/headshots/nba/players/full/4600663.png"
  },
  "injuryId": "533071",
  "status": "Day-To-Day",
  "statusAbbreviation": "DD",
  "statusType": "INJURY_STATUS_DAYTODAY",
  "isInjured": true,
  "fantasyStatus": "GTD",
  "injury": { "type": "Ankle", "detail": "Surgery", "side": "Left", "location": "Leg" },
  "expectedReturnDate": "2026-10-05",
  "shortComment": "Edey (ankle) remains on track for Opening Night, per Drew Hill of The Daily Memphian.",
  "longComment": "The Grizzlies continue to evaluate Edey throughout training camp, and they believe he's trending in the right direction. Fantasy managers should keep an eye on his recovery from elbow and ankle surgeries.",
  "source": "RotoWire",
  "date": "2026-10-02T20:16Z",
  "dateLocal": "2026-10-02T16:16:00.000-04:00",
  "retrievedAt": "2026-10-03T09:22:06.485Z"
}
```

The **Output** tab shows two tables: **Injury report** (player, team, status, injury, expected return and the latest note) and **Injury details** (body part, type, side, fantasy status and the full note).

#### Output fields

| Field | Description |
|-------|-------------|
| `league`, `leagueName`, `sport` | League code (`nfl`), name (`NFL`) and sport |
| `season` | Season year, phase (`Preseason`, `Regular Season`, `Postseason`) and label (`2026-27`) |
| `team` | Team ESPN ID, name and abbreviation |
| `player` | ESPN player ID, name, short name, position and headshot URL |
| `status` | Status as ESPN shows it, e.g. `Out`, `Day-To-Day`, `60-Day-IL` |
| `statusAbbreviation` | Short status, e.g. `O`, `Q`, `DD`, `IR`, `IL60` |
| `isInjured` | `false` only for `Active` (a news note on a healthy player) |
| `fantasyStatus` | Fantasy designation, e.g. `OUT`, `GTD`, `IR`, `IR-R`, `PUP-R`, `15-Day IL` |
| `injury.type` | Body part or reason, e.g. `Knee`, `Hamstring`, `Lower Body`, `Illness` |
| `injury.detail` | Kind of injury, e.g. `Sprain`, `Strain`, `Fracture`, `Surgery` |
| `injury.side` | `Left` or `Right` |
| `injury.location` | Body region, e.g. `Leg`, `Arm`, `Torso` (NFL and NBA) |
| `expectedReturnDate` | ESPN's estimated return date |
| `shortComment` | One-line news note |
| `longComment` | Full note with the outlook |
| `source` | Who wrote the note, e.g. `RotoWire` |
| `date` / `dateLocal` | When the report was posted, in UTC and US Eastern time |
| `retrievedAt` | When your run collected the data. It is the same for every row of a run, so daily snapshots are easy to group |

A field is `null` when ESPN does not give it. `injury.type` and `expectedReturnDate` are set for nearly every injured player in the NFL, NBA, MLB, NHL and WNBA. `injury.detail` and `injury.side` are set only when the team discloses them.

Each run also saves a **run summary** in the key-value store under `SUMMARY`. It contains the row counts, the leagues, the filters, and any team or player name that was not on the report.

**Good to know:**

- `date` is when ESPN posted the report, not when the injury ends. A player placed on injured reserve in August keeps that August date all season. For this reason "Only reports from the last N days" is empty by default, because a short window would hide long-term injuries.
- `expectedReturnDate` is an estimate. For season-ending injuries it is often the start of the next season (for example 1 February for MLB).

### How to use ESPN Injury Report Scraper

#### In Apify Console

1. Open the Actor and fill in the input form.
2. Click **Start**.
3. Open the **Output** tab, or export the results.

Save your setup as a **task** to run it again with one click, or add a **schedule** to run it every day.

#### With the Apify API (HTTP)

Run the Actor and get the results in one HTTP call. Replace `YOUR_API_TOKEN` with your token from **Settings → API & Integrations** in Apify Console.

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~espn-injury-report-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"leagues": ["nfl"], "injuryStatuses": ["Out", "Doubtful", "Questionable"]}'
```

Add `&format=csv` to the URL to get CSV instead of JSON.

#### With the JavaScript client

Install the client with `npm install apify-client`.

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('hgservices/espn-injury-report-scraper').call({
    leagues: ['nba'],
    injuryStatuses: ['Out', 'Day-To-Day'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.player.name, item.status, item.injury.type, item.expectedReturnDate);
}
```

#### With the Python client

Install the client with `pip install apify-client`.

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("hgservices/espn-injury-report-scraper").call(
    run_input={"leagues": ["mlb"], "injuryStatuses": ["Injured Reserve"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["player"]["name"], item["status"], item["injury"]["type"], item["expectedReturnDate"])
```

#### With Claude, ChatGPT and other AI assistants (MCP)

Connect your AI assistant to the **Apify MCP server**. Then ask in plain language. The assistant runs this Actor for you and answers from the results. To give the assistant this Actor as a tool, use this server URL:

```
https://mcp.apify.com?tools=hgservices/espn-injury-report-scraper
```

- **Claude (claude.ai or Claude Desktop):** go to **Settings → Connectors**, add a custom connector, and paste the URL above.
- **Claude Code:** run `claude mcp add --transport http apify "https://mcp.apify.com?tools=hgservices/espn-injury-report-scraper"`.
- **ChatGPT:** add the URL above as a custom connector (MCP server) in ChatGPT's connector settings.
- **Cursor, VS Code, Windsurf and other MCP clients:** add the URL above as an HTTP MCP server.

Sign in with your Apify account when the assistant asks. Example prompts:

- *"Who is out for the Chiefs this week?"*
- *"List every NBA player who is day-to-day today, with the injury and the expected return date."*
- *"Which MLB pitchers are on the 60-day IL?"*
- *"Is Patrick Mahomes injured? Show me the latest note."*

#### With integrations

Send the results to **Google Sheets, Slack, Discord, email, Zapier, Make, n8n, Airbyte** or any **webhook** from the Actor's **Integrations** tab. A common setup: run every morning, then post new "Out" players to a Slack channel.

### Scheduling ideas

| Use case | Cron (UTC) | When |
|----------|------------|------|
| Daily injury report | `0 13 * * *` | Every day at 9 AM US Eastern |
| NFL Sunday pre-lock check | `0 16 * * 0` | Sunday noon US Eastern, before the early kickoffs |
| NBA pre-game check | `0 22 * * *` | Every day at 6 PM US Eastern |

### FAQ

**How current is the data?**
Each run gets the injury report as ESPN shows it at that moment. Run it again, or schedule it, for newer data.

**Why do I see fewer rows than on the ESPN website?**
By default, news notes on healthy players (status "Active") are not included. Add "Active" to the injury status filter to include them.

**My team or player filter returns nothing. Why?**
The injury report lists only injured players and the teams that have them. If a name in your filter is not on today's report, the run status and the run log name it, and the log lists every team on the report. You can use the team abbreviation (`KC`) or the team name (`Chiefs`).

**Does it include the body part and the return date?**
Yes. `injury.type` gives the body part (for example `Knee`), `injury.detail` the kind of injury when it is known, `injury.side` the side, and `expectedReturnDate` ESPN's estimated return date.

**Can I combine it with other sports data?**
Yes. See the related Actors below. They use the same league codes, team fields and player fields, so their data joins directly.

### Related Actors

- **[ESPN Depth Chart Scraper](https://apify.com/hgservices/espn-depth-chart-scraper)** — starters and backups at every position. Combine it with injuries to find the player who replaces an injured starter.
- **[ESPN Transactions Scraper](https://apify.com/hgservices/espn-transactions-scraper)** — signings, releases, trades and IL moves.
- **[ESPN Sports Scores & Schedules](https://apify.com/hgservices/apify-actor-espn)** — scores, schedules, venues and broadcasts for every game.

### Feedback

Do you need a league, a field or a filter that is not here? Open an issue on the Actor's **Issues** tab. We read every request.

### Disclaimer

This Actor is not affiliated with, endorsed by or sponsored by ESPN. It collects publicly available injury information. Use the data in line with ESPN's terms and the laws that apply to you.

# Actor input Schema

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

Leagues to get injury reports for. ESPN publishes no injury reports for college basketball or soccer, so those leagues are not offered.

## `injuryStatuses` (type: `array`):

Only return players with these statuses. Leave empty for every player who is hurt, sick, suspended or on leave. ESPN also posts news notes on healthy players with the status 'Active' (about two thirds of NFL rows); select 'Active' to include them.

## `teams` (type: `array`):

Only return these teams. Use the abbreviation (KC, LAL, NYY) or the team name (Chiefs, Kansas City Chiefs). Leave empty for every team.

## `players` (type: `array`):

Only return players whose name contains one of these terms (e.g. 'mahomes', 'LeBron James'). Leave empty for every player.

## `positions` (type: `array`):

Only return these positions. Use the abbreviation (QB, WR, SP, G) or the name (Quarterback, Pitcher). Leave empty for every position.

## `injuryReportedWithinDays` (type: `integer`):

Drop reports older than this many days. Leave empty to get every current injury. A player placed on injured reserve months ago keeps that original date, so a short window hides long-term injuries.

## Actor input object example

```json
{
  "leagues": [
    "nfl"
  ],
  "injuryStatuses": [],
  "teams": [],
  "players": [],
  "positions": []
}
```

# Actor output Schema

## `injuries` (type: `string`):

One row per player on the injury report, newest first

## `injuryDetails` (type: `string`):

Body part, kind of injury, side, fantasy designation and the full note

## `summary` (type: `string`):

Row counts, leagues, filters and any league ESPN did not answer for

# 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": [
        "nfl"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/espn-injury-report-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 = { "leagues": ["nfl"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/espn-injury-report-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "nfl"
  ]
}' |
apify call hgservices/espn-injury-report-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/espn-injury-report-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/anp0b5dAFBTvPf1rD/builds/WBFENo3otgnWeJBGQ/openapi.json