# Sports Injury Reports & Status Changes (`automatic/sports-injuries`) Actor

Player injury and availability reports for the NFL, NBA, NHL, MLB and WNBA: one record per listed player with a normalised status, injury detail, comments, expected return and the team's next game. Change mode tracks new, updated and cleared listings.

- **URL**: https://apify.com/automatic/sports-injuries.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Sports
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 injury records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Sports Injury Reports & Status Changes

Collect the current player injury and availability report for the NFL, NBA,
NHL, MLB and WNBA as published by ESPN: one record per listed player with a
normalised status (out, doubtful, questionable, day to day, injured reserve
and more), the injury, the expected return date and the team's next game
(the text note published with an entry is optional and off by default). An optional change mode returns only the
players whose status, comment or expected return changed since your previous
run, plus the players who are no longer listed. Built for bettors, fantasy
players, preview writers and model builders who schedule runs and pipe the
JSON into alerts, dashboards or models. No account or API key is needed.

Data only: not medical, betting or financial advice. This is an unofficial
tool: it is not affiliated with or endorsed by ESPN, any league or any team.

### Use cases

- **Availability before a bet or a fantasy lock:** who is out, doubtful or
  questionable for the leagues or teams you follow, each with the team's next
  game and its start time.
- **Alerts on status changes:** schedule a run with change mode on and get a
  record only when a player's status moves (for example out to questionable),
  when a player is added, or when a player drops off the report.
- **Game previews:** a "who is out" line per team, joined to the game through
  the next game's event id.
- **Models and research:** a stable key per player and a small status
  vocabulary across five leagues, with the source's own wording kept next to
  it.

### Quick start

1. Open the Actor and click **Start**. The prefilled form collects the NFL and
   NBA reports with each team's next game, capped at 20 records.
2. Read the rows in the **Output** tab, or export them as JSON, CSV or Excel.

Two teams, only the players in doubt for the next game:

```json
{"leagues": ["nba"], "teams": ["LAL", "BOS"], "statuses": ["out", "doubtful", "questionable", "day_to_day"]}
```

Only what changed since the last run of the same watch list:

```json
{"leagues": ["nfl", "nba", "nhl"], "emitChangesOnly": true, "stateKey": "my-watch-list"}
```

Every league, without the next-game lookup:

```json
{"leagues": ["nfl", "nba", "nhl", "mlb", "wnba"], "attachNextGame": false, "maxResults": 2000}
```

An empty input (`{}`) returns a sample of up to 20 current NFL and NBA
injury records. The run status starts with "Sample run (...)" and the run
summary has `sampleRun: true`. Any explicit input runs the requested scope,
with a default cap of 1,000 unless you set `maxResults`. The Console form
prefills a cap of 20. A full NFL and NBA snapshot can be requested with
`maxResults: 1000`; its size changes through the day (301 records during the
2026-11-11 audit). The Actor never widens the league scope by itself.

### Input

| Name | Type | Default | What it does |
| --- | --- | --- | --- |
| `leagues` | array | NFL and NBA | Leagues to collect: `nfl`, `nba`, `nhl`, `mlb`, `wnba`. |
| `teams` | array | every team | Only these teams: abbreviations as the source writes them (`LAL`, `KC`, `GS`, `NO`, `NY`, `SA`, `UTAH`, `WSH`), full team names or numeric team ids. |
| `statuses` | array | every status except `active` | Any of `out`, `doubtful`, `questionable`, `probable`, `day_to_day`, `injured_reserve`, `suspended`, `active`, `unknown`. |
| `includeComments` | boolean | `false` | Add the short and long comment published with each entry. Off by default because the comments are editorial text written by a third party. |
| `attachNextGame` | boolean | `true` | Add each team's next scheduled game. |
| `nextGameDays` | integer | `7` | Days from today to search for the next game (1–10). |
| `emitChangesOnly` | boolean | `false` | Change mode: return only what changed since the previous run with the same state key. |
| `stateKey` | string | derived from leagues and teams | Name of the saved state change mode compares against. At most 64 characters. |
| `maxResults` | integer | `1000` (20 for `{}`) | Maximum dataset records per run (1–5,000). |
| `requestDelaySecs` | number | `1` | Seconds between requests (0.25–10). |

An explicit `leagues: []` is an error: omit `leagues` for NFL and NBA.
`teams: []` means every team; `statuses: []` means every status except
`active`; `stateKey: ""` derives a key. These explicit inputs are full runs,
so set `maxResults` to keep them small. Null values and strings in place of
list fields are errors.

A misspelt input field, an unsupported league or a value outside these limits
stops the run with an error that names the problem. A `teams` value that
matches no team on the report is listed in the run summary's `notes`.

### Output

One record per player on a league's report.

- **Identity:** `recordKey` (`espn:injury:<league>:<athleteId>`, stable
  across runs), `sport`, `league`, `leagueLabel`, `seasonYear`, `seasonType`,
  `sourceUrl` (the player's page).
- **Who:** `team` (`id`, `name`, `abbreviation`) and `player` (`id`, `name`,
  `firstName`, `lastName`, `position`, `positionName`, `jersey`).
- **Status:** `status` is one of `out`, `doubtful`, `questionable`,
  `probable`, `day_to_day`, `injured_reserve`, `suspended`, `active` or
  `unknown`. The source's own wording is kept in `statusNative` (for example
  `Day-To-Day`), its status code in `statusType`, and its short designation
  in `designation` (for example `GTD`, `OFS`, `IR-R`, `PUP-R`, `7-Day IL`).
- **Injury:** `injury` with `type` (Hamstring), `location` (Leg), `detail`
  (Strain) and `side` (Left), each `null` when not published.
- **Notes and dates:** `shortComment`, `longComment`, `commentSource` (who
  wrote the comment, when stated), `reportedAt` (when the entry was last
  updated, UTC), `expectedReturn` (estimated return day), `collectedAt`.
- **Next game:** `nextGame` with `espnEventId`, `startTime` (UTC),
  `shortName` (`LAL @ MIL`), `homeAway` and `opponent`; `null` when the team
  has no game in the look-ahead window or the lookup is off.
- **Change:** `change` is `null` in a normal run. In change mode it holds
  `kind` (`new`, `updated` or `cleared`), `previousStatus`, `newStatus`,
  `previousSeenAt`, `previousExpectedReturn` and `changedFields` (`status`,
  `comment`, `expectedReturn`).

How to read it:

- Anything not published is `null`. Nothing is estimated: the status comes
  only from the source's status field, never from the wording of a comment.
- `unknown` means the source used a status this Actor does not recognise;
  read `statusNative`.
- `expectedReturn` is the source's estimate and is often a placeholder date
  for long-term absences.
- A `cleared` record means the player is no longer on the report. It does not
  say why: usually the player is available again, but the entry can also have
  been removed for another reason. Its `status` is `null` and
  `change.previousStatus` holds the last status seen.

The run summary (`OUTPUT` in the key-value store) reports records per league
and per status, how many have a next game, the newest and oldest
`reportedAt`, requests made, the change counts, warnings, the `sampleRun`
flag and the status
`succeeded`, `succeeded_empty`, `succeeded_partial` or `failed`.

### Output example

A full real NBA record captured on 2026-11-11. Comments are null because
`includeComments` was left off; dates and the next game reflect that capture.

```json
{"recordKey":"espn:injury:nba:4873201","source":"espn","schemaVersion":"1.0","collectedAt":"2026-11-11T18:41:43.708499+00:00","sourceUrl":"https://www.espn.com/nba/player/_/id/4873201/asa-newell","sport":"basketball","league":"nba","leagueLabel":"NBA","seasonYear":2027,"seasonType":2,"team":{"id":"1","name":"Atlanta Hawks","abbreviation":"ATL"},"player":{"id":"4873201","name":"Asa Newell","firstName":"Asa","lastName":"Newell","position":"F","positionName":"Forward","jersey":null},"status":"out","statusNative":"Out","statusType":"INJURY_STATUS_OUT","designation":"GTD","injury":{"type":"Toe","location":"Leg","detail":null,"side":"Left"},"shortComment":null,"longComment":null,"commentSource":null,"reportedAt":"2026-11-08T22:15:00+00:00","expectedReturn":"2026-11-13","injuryId":"538188","nextGame":{"espnEventId":"401909299","startTime":"2026-11-14T01:00:00+00:00","shortName":"ATL @ CHI","homeAway":"away","opponent":{"id":"4","name":"Chicago Bulls","abbreviation":"CHI"}},"change":null}
```

### Pricing

The approved price is **$0.0003 per dataset record ($0.30 per 1,000), plus
$0.001 per run start**. See the Actor's **Pricing** tab for current rates.

| Run | Records | Record and start charges |
| --- | ---: | ---: |
| Bare sample or Console prefill at its cap | 20 | $0.007 |
| Full NFL and NBA snapshot measured during the audit | 301 | $0.0913 |
| Quiet change poll | 0 | $0.001 |
| Change poll with two delivered changes | 2 | $0.0016 |

Use `leagues`, `teams`, `statuses`, `emitChangesOnly` and `maxResults` to keep
runs small. Unchanged players and records withheld by the spending limit
add no record charge. The run summary's `records` counts delivered rows;
`coverage` counts selected rows before the spending limit.

### Scheduling and monitoring

- **Status alerts:** schedule a run with `emitChangesOnly` every 10 to 30
  minutes on game days and send each record to your alert channel. Give the
  schedule a `stateKey`; every run with that key shares one history, and a
  different key starts a new one.
- **How change mode behaves:** the first run for a state key reports a
  baseline and returns every listed player as `new`. Later runs return only `new`, `updated` and
  `cleared` records; a run with nothing to report returns no records. A
  change is returned when the previous or the new status is in `statuses`,
  so a player going from questionable to active is reported with the
  default filter. Changes above `maxResults` or above your spending limit
  are kept and returned by the next run.
- **Daily snapshot:** schedule a normal run once a day and key your history
  on `recordKey` plus `collectedAt`.
- If a league's report cannot be read, the run says so in its warnings and
  that league's players are left as they were; they are not reported as
  cleared.

### How current the report is

Measured on 2026-11-11 at about 01:00 UTC; it changes through the day and
the season.

| League | Players listed | Updated in the last 24 hours | Notes |
| --- | --- | --- | --- |
| NFL | 800 (203 without `active`) | 200 | At most 25 entries per team, newest first, including player news listed as `active`. |
| NBA | 91 | 33 | In season. |
| NHL | 111 | 12 | In season; most entries are injured reserve. |
| MLB | 146 | 6 | Off season: long-term entries only. |
| WNBA | 44 | 1 | Off season: long-term entries only. |

Between two looks twenty minutes apart that evening, 12 of 1,002 NFL, NBA and
NHL entries changed; 2 of them were injury records, the rest NFL player news.

### FAQ

**Which statuses does each league use?** On 2026-11-11 the NFL list used
questionable, doubtful, out, injured reserve and active; the NBA out and day
to day; the NHL injured reserve, out and day to day; MLB out, day to day and
suspended; the WNBA out.

**Why is an NBA player "day to day" when the comment says questionable?** For
the NBA the source's status field only says out or day to day. The league's
own questionable, doubtful and probable labels appear in the comment text.
This Actor does not turn comment wording into a status; read `shortComment`,
or `designation` (`GTD`).

**Why are NFL "active" players left out by default?** For the NFL the source
lists recent player news (game recaps, signings) with the status active. They
are not injuries, and they are most of the NFL list. Add `active` to
`statuses` to receive them.

**Why does a record have no next game?** The team has no scheduled game within
`nextGameDays` (a bye week, the off season), or `attachNextGame` is off. A
game already in progress is not a next game.

**How fresh is the data?** Each run reads the report at run time.

**Does a team filter change what change mode remembers?** Each combination
of leagues and teams gets its own saved state unless you set `stateKey`.

**Export formats?** JSON, CSV, Excel, XML or RSS from the dataset, or read it
through the Apify API in your own pipeline.

### Limits

- One source. The data comes from an unofficial, undocumented source that
  can change or become unavailable without notice, and it can lag behind or
  differ from the leagues' official reports. Check a run's status and
  warnings before relying on it.
- Leagues not covered: college football (the source's list is years out of
  date), college basketball, UFC and every soccer league, including the
  Premier League, La Liga and MLS (the source publishes no entries for
  them). The run refuses them with that reason.
- NFL: at most 25 entries per team are published, newest first, so on a busy
  news day an older injury entry can drop off the list and be reported as
  `cleared` in change mode.
- No practice participation, no snap or minutes restrictions, no official
  game-day inactive lists, no history: build history by scheduling runs.
- Jersey numbers are not published in this report (`player.jersey` is
  `null`), and player photos and team logos are not included.
- Comments are short notes written by a third party for the source
  (`commentSource` names it). They are editorial text, not facts like a status
  or a date, so they are left out unless you turn `includeComments` on; when
  on, they are passed through unchanged and their use is your responsibility.
- You are responsible for using the data in line with the terms of the sites
  it comes from and the laws that apply to you.

For support, contact Apify support and include the Actor run ID.

# Actor input Schema

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

Leagues to collect. Omit for NFL and NBA. An empty list is an error. A bare input ({}) returns an announced sample of at most 20 records; any explicit input runs the requested scope.

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

Only these teams: abbreviations as the source writes them (for example LAL, BOS, KC, GS, NO, NY, SA, UTAH, WSH), full team names or numeric team ids. Leave empty for every team. A numeric id is matched in every selected league, so use it with one league.

## `statuses` (type: `array`):

Only players with these statuses. Leave empty for every status except Active: for the NFL the source also lists recent player news under Active, which is not an injury. In change mode a change is returned when the previous or the new status is in this list.

## `includeComments` (type: `boolean`):

Off by default: records carry status, injury and dates only. Turn on to add the short and long text note published with each entry. Those notes are editorial text written by a third party (credited in commentSource), so check that your use of them is allowed. Comment changes are detected in change mode either way.

## `attachNextGame` (type: `boolean`):

Add the team's next scheduled game (event id, start time, opponent, home or away) to each record. Costs one schedule lookup per league per day until every listed team has a game, at most the number of days below.

## `nextGameDays` (type: `integer`):

How many days from today (US Eastern days) to search for each team's next game. A team with no game in that window gets no next game.

## `emitChangesOnly` (type: `boolean`):

Return only players whose status, comment or expected return changed since the previous run with the same state key, plus players who are no longer listed (cleared). The first run returns every listed player as new.

## `stateKey` (type: `string`):

Name of the saved state that change mode compares against. Runs with the same key share one history, so give every schedule of the same watch list the same key. Leave empty to derive it from the leagues and teams. Letters, digits and ! - \_ . ' ( ) only, at most 64 characters.

## `maxResults` (type: `integer`):

Stop after this many dataset records (1–5,000). Omitted: 20 for a bare sample, otherwise 1,000. The Console prefill is 20. In change mode, changes beyond the limit are kept for the next run instead of being dropped.

## `requestDelaySecs` (type: `number`):

Seconds between request starts. The default of 1 keeps the run to about one request per second.

## Actor input object example

```json
{
  "leagues": [
    "nfl",
    "nba"
  ],
  "includeComments": false,
  "attachNextGame": true,
  "nextGameDays": 7,
  "emitChangesOnly": false,
  "maxResults": 20,
  "requestDelaySecs": 1
}
```

# Actor output Schema

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

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "leagues": [
        "nfl",
        "nba"
    ],
    "includeComments": false,
    "attachNextGame": true,
    "nextGameDays": 7,
    "emitChangesOnly": false,
    "maxResults": 20,
    "requestDelaySecs": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/sports-injuries").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",
        "nba",
    ],
    "includeComments": False,
    "attachNextGame": True,
    "nextGameDays": 7,
    "emitChangesOnly": False,
    "maxResults": 20,
    "requestDelaySecs": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/sports-injuries").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",
    "nba"
  ],
  "includeComments": false,
  "attachNextGame": true,
  "nextGameDays": 7,
  "emitChangesOnly": false,
  "maxResults": 20,
  "requestDelaySecs": 1
}' |
apify call automatic/sports-injuries --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/sports-injuries"
        }
    }
}
```

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/1SJdevxtscBkr7MJP/builds/N2CTAQOnZQEGnfnAF/openapi.json