# Sports Injury Report API — NFL, NBA, MLB, NHL (`lergassy/sports-injuries-api`) Actor
Every injured player in NFL, NBA, MLB, NHL and WNBA as rows: status, body part, surgery, expected return date and the analyst note — joined to the games each team is about to play, so you see which side takes the field short-handed. No API key or login.
- **URL**: https://apify.com/lergassy/sports-injuries-api.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Sports, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.18 / 1,000 injured players
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?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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
**Sports Injury Report API** turns the injury report into data: every hurt player in the **NFL, NBA, MLB, NHL and WNBA** as a clean row with the **status, the body part, whether there was surgery, the date they are expected back** and the analyst note — and then joins that report to the games each team is about to play, so one row tells you which side takes the field short-handed and by how many.
No API key, no proxy, no browser. A full sweep of all four major leagues takes a few seconds.
### What is Sports Injury Report API?
It is the missing half of an odds feed. Lines move on injuries: a starting quarterback ruled out on Friday moves a spread further than anything else that happens that week. Betting models, fantasy tools, sports newsletters and AI agents all need to answer "who is out tonight" — and the usual answer is either a $200-a-month licensed feed or a scraper that returns a flat list you still have to match to the schedule yourself.
Three things set it apart from a plain injury scraper:
- **Games mode.** Every upcoming game with both sides' injury load next to it: how many are hurt, how many are actually out, who they are, and `injuryEdge` — the difference in players missing, positive when the home side is the healthier one. This is the shape the question is usually asked in, and no other injury Actor produces it.
- **Real injuries only.** ESPN's feed also carries roster notes about perfectly healthy players — depth-chart moves, contract news — under the status *Active*, with no injury, no body part and no return date. On an NFL sweep they were **more than half the rows**. They are dropped by default, so you are not paying for rows that are not injuries. Switch them back on with one checkbox if you want ESPN's whole note feed.
- **Expected return dates.** Where ESPN has one, the row carries the date the player is expected back, so "out" and "out for the season" stop looking the same.
### What data does it return?
#### Injuries mode — one row per player
Every field below is on every injury row, filled where ESPN has the value and empty rather than guessed where it does not.
| Field | Example |
|---|---|
| `league`, `leagueName` | nfl · National Football League |
| `team`, `teamId`, `teamAbbreviation`, `teamLogo` | Arizona Cardinals · 22 · ARI |
| `player`, `shortName`, `playerId`, `playerUrl`, `headshot` | Kaleb Proctor · K. Proctor · 5084514 · espn.com/nfl/player/… |
| `position`, `positionAbbreviation` | Defensive Tackle · DT |
| `status`, `statusType`, `statusAbbreviation` | Injured Reserve · Injured Reserve · IR |
| `injuryType`, `bodyLocation`, `detail`, `side` | Knee - Meniscus · Leg · Surgery · Not Specified |
| `returnDate` | 2027-02-15 |
| `comment`, `shortComment`, `reportedAt` | the analyst note · ir · 2026-09-08T20:42Z |
| `playerStatus`, `fantasyStatus` | Day-To-Day · IR |
| `injuryId`, `scrapedAt` | -1998810 · 2026-09-09T07:40:00Z |
`returnDate` is filled for roughly four rows in ten — ESPN gives one for serious injuries and leaves it out for a knock reported this morning.
`status` is the league's own word for the designation — *Out*, *Questionable*, *Doubtful*, *Day-To-Day*, *Injured Reserve*, *Suspension*. `statusType` is ESPN's normalised version of the same thing and `statusAbbreviation` the short form (IR, DTD), so you can filter on whichever your pipeline already speaks.
#### Teams mode — one row per team
`team`, `injuredCount`, `outCount`, `byStatus` (how many at each status), `outPlayers` (name, position, injury, expected return) and, unless you turn it off, `players` — the full injured list. Sorted with the worst-hit teams first.
#### Games mode — the schedule with the injuries attached
| Field | Example |
|---|---|
| `league`, `eventId`, `game`, `shortName` | nfl · 401872656 · New England Patriots at Seattle Seahawks · NE @ SEA |
| `startTime`, `status`, `statusDetail`, `venue` | 2026-09-10T00:20Z · pre · Wed, September 9th at 8:20 PM EDT · Lumen Field |
| `homeTeam`, `homeTeamId`, `awayTeam`, `awayTeamId` | Seattle Seahawks · 26 · New England Patriots · 17 |
| `homeInjuredCount`, `homeOutCount` | 8 · 6 |
| `homeOutPlayers` | `[{player, position, injuryType, returnDate}, …]` |
| `homePlayers` | the full injured list, unless you switch it off |
| `awayInjuredCount`, `awayOutCount`, `awayOutPlayers`, `awayPlayers` | the same four for the visiting side |
| `injuryEdge`, `espnLink` | 3 · espn.com/nfl/game/… |
A real row from one run: *New England Patriots at Seattle Seahawks* — Seattle 6 players out, New England 9, `injuryEdge` +3 to the home side.
#### Error and note rows
Two row types exist besides the data, and neither is ever charged for.
An **error** row appears when a source could not be read: `type: "error"`, the `url` that failed, the `error` message and `kind` telling you which source it was. A run that hits one bad league still returns the others.
A **note** row appears when an empty answer is the honest answer — a league ESPN keeps no injury list for, or a day with no games scheduled. It says so in plain words rather than leaving you to guess whether the Actor broke.
### Why injury data belongs next to odds
A betting line is a forecast, and the forecast changes most when the roster does. A starting quarterback ruled out on a Friday moves a spread further than any other single piece of news that week; a rested star scratched an hour before an NBA tip-off moves a total. That is why every serious model treats the injury report as an input rather than as context.
The practical problem has never been finding injury news — it is joining it to the right game in time. A flat list of injured players tells you Player X is out; it does not tell you that Player X's team plays on Sunday, who they play, and how many are missing on the other side. Games mode does that join for you, which is why it exists and why it is priced as its own row.
`injuryEdge` is deliberately simple: away players out minus home players out. It is not a model and does not pretend to be one — it is the first number you would compute yourself, computed for you, so it can go straight into a filter or a spreadsheet column.
### How much does it cost?
Pay per row, and error rows are free. Platform usage is close to zero: no browser, no proxy.
| Row | Price |
|---|---|
| Injured player | $0.00025 — 4,000 players for $1 |
| Team injury report | $0.002 |
| Game with both sides attached | $0.004 |
A full NFL injury sweep is about 300 rows, or $0.08. An NFL week in games mode is 16 rows, or $0.06. Larger monthly plans get 10–30 % off.
### How to use it
1. Pick **🏆 Leagues** — NFL, NBA, MLB, NHL, WNBA or college football.
2. Choose **🩹 What to get**: *Injuries* for the player list, *Teams* for the per-team load, *Games* for the schedule with both sides attached.
3. Tick **🚫 Only players who will not play** if you only care about who is definitely missing.
4. Click **Start**. Export as JSON, CSV or Excel, run it on a schedule to keep a history, or call it from the API.
#### Who is out in the NFL right now
```json
{ "mode": "injuries", "leagues": ["nfl"], "outOnly": true }
```
#### This week's games with both sides' injuries
```json
{ "mode": "games", "leagues": ["nfl", "nba"], "daysAhead": 7 }
```
#### Only quarterbacks, only one team
```json
{ "mode": "injuries", "leagues": ["nfl"], "teams": ["KC"], "positions": ["QB"] }
```
#### Every team ranked by how badly it is hit
```json
{ "mode": "teams", "leagues": ["nba"] }
```
### Use cases
#### Betting and odds models
Injuries are the largest single driver of line movement. Games mode gives the schedule and the missing players in one row, ready to join to an odds feed — pair it with [Sports Betting Odds API](https://apify.com/lergassy/sports-odds-api) for the prices on the same games, matched by team name and start time.
#### AI agents
The rows are flat, every field is described in the dataset schema and nothing in the input form is required, so an agent asked "who is out for the Chiefs on Sunday" can call the Actor correctly without reading a manual. It is exposed through Apify's MCP server as a tool.
#### Fantasy and DFS
`status`, `fantasyStatus` and `returnDate` per player, filtered to the positions you start.
#### Keeping a history
Run the Actor on a schedule and each run appends to its own dataset, so you build your own record of how a status moved — questionable on Wednesday, out on Friday. `reportedAt` on every row makes the sequence exact.
#### Newsletters, bots and dashboards
"Who is out tonight" answered in one call, with the analyst note ESPN publishes alongside each injury.
#### AI agents
Flat, fully documented rows and a plain input form, so an agent can ask for one team, one position or one league without reading a manual.
#### Research
Injury frequency by position, by body part and by team, or how long a given injury type actually keeps a player out — `injuryType`, `bodyLocation`, `detail` and `returnDate` are separate fields precisely so they can be grouped.
### Troubleshooting
**The run returned a note row and nothing else.** The league has no injury list at ESPN (soccer, college basketball) or has no games in the window you asked for. Widen `daysAhead` or pick a league from the covered list.
**A team I asked for is missing.** The team filter matches on the full name, the abbreviation or the ESPN team id. `Kansas City Chiefs`, `KC` and `12` all work; `Chiefs` alone does not.
**Fewer rows than expected.** Roster notes about healthy players are dropped by default — that is usually most of ESPN's feed. Turn on *Include ESPN's notes about healthy players* if you want them back.
**A player has no id.** ESPN leaves the athlete id out of the injury feed; the Actor recovers it from the headshot file name, so a player without a photo has no id. Name and team are always present.
### Notes and limits
- ESPN publishes injury lists for the North American leagues. **Soccer and college basketball have none**, which is why they are not offered — an empty answer there would be the source's, not the Actor's.
- College football is covered but thin: ESPN maintains far less of it than the professional leagues.
- The data is ESPN's public feed, reported as ESPN reports it. This Actor is unofficial and not affiliated with ESPN or any league.
### Integrations
The Actor is a normal Apify Actor, so everything the platform offers works out of the box.
- **API** — `POST https://api.apify.com/v2/acts/lergassy~sports-injuries-api/run-sync-get-dataset-items?token=…` returns the rows in one call, ready for a script or an agent.
- **Python client**
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("lergassy/sports-injuries-api").call(run_input={
"mode": "games", "leagues": ["nfl"], "daysAhead": 7,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
print(row["game"], row["homeOutCount"], "vs", row["awayOutCount"])
```
- **JavaScript client**
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('lergassy/sports-injuries-api').call({ mode: 'injuries', leagues: ['nba'], outOnly: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```
- **n8n, Make, Zapier and Google Sheets** — the standard Apify connectors; point them at this Actor and map the fields.
- **MCP server** — the Actor is exposed through Apify's MCP server, so an AI agent can call it as a tool. The input form is short, every field is described and nothing is required, which is what an agent needs to call it correctly without reading anything.
- **Webhooks and schedules** — run it every morning and push the new injury report wherever you keep it.
### ❓ FAQ
#### Is it legal to scrape injury reports?
The Actor reads ESPN's public data — the same pages anyone can open in a browser, with no login and no paywall. Public factual data about professional sports is generally fine to collect, but the law depends on your country and on what you do with the data afterwards, so consult a lawyer for your own case. This Actor is unofficial and not affiliated with ESPN or any league.
#### How much does an injury report cost?
$0.25 per 1,000 injured players, $2 per 1,000 team reports and $4 per 1,000 games with both sides attached. A full NFL sweep is about 300 rows — eight cents. See the pricing table above.
#### Can I use it with the Apify API?
Yes. Every mode is reachable through `run-sync-get-dataset-items`, so one HTTP call returns the rows. There is a Python and a JavaScript snippet in Integrations.
#### Can I use it through an MCP server?
Yes. It runs as a tool on Apify's MCP server, and the input schema is written for that: short titles, a described tooltip on every field, sensible defaults, nothing required.
#### Can I integrate it with other apps?
Yes — n8n, Make, Zapier, Google Sheets, Slack and webhooks, through the standard Apify integrations.
#### Is it one row per player?
In Injuries mode, yes. Teams mode gives one row per team and Games mode one row per game, with the players nested inside.
#### Why is a player missing an expected return date?
ESPN publishes a return date for serious injuries and leaves it out for a knock reported that morning. Roughly four rows in ten carry one. The field is empty rather than guessed.
#### Which leagues are covered?
NFL, NBA, MLB, NHL, WNBA and college football. ESPN keeps no injury lists for soccer or college basketball, so those are not offered — an empty answer there would be the source's, not the Actor's.
#### How often is the data updated?
ESPN updates the report continuously; each row carries `reportedAt` so you can see when the status last changed. Schedule the Actor to run as often as you need.
### Your feedback
If a field is missing, a status looks wrong or a league you need is not covered, open an **Issue** on this Actor's page or leave a review — both go straight to the developer and are answered the same day. Feature requests are welcome: several fields in the output exist because someone asked.
### You might also like
| Actor | What it does |
|---|---|
| [Sports Betting Odds API](https://apify.com/lergassy/sports-odds-api) | Moneyline, spread and total odds per book — Pinnacle sharp lines with risk limits, DraftKings, Kalshi — plus arbitrage and value bets. The prices for the games in this Actor. |
| [Sports Scores & Schedules API](https://apify.com/lergassy/espn-scores-api) | Live scores, schedules, standings, rosters and box scores for the same leagues. |
| [Tennis Scores & Stats API](https://apify.com/lergassy/tennis-scores-api) | ATP and WTA matches, draws, rankings and player statistics. |
| [WTA Tennis Scraper](https://apify.com/lergassy/wta-tennis-scraper) | Player profiles, rankings and results from the WTA tour. |
# Actor input Schema
## `mode` (type: `string`):
Injuries — one row per injured player with the body part, the surgery and the expected return date. Teams — one row per team: how many are hurt, how many are actually out, and who. Games — the upcoming schedule with each side's injury load next to it, so you can see which team takes the field short-handed.
## `leagues` (type: `array`):
ESPN keeps injury lists for the North American leagues. Soccer and college basketball have none, so those are not offered.
## `outOnly` (type: `boolean`):
Keeps Out, Injured Reserve, the IL lists and suspensions, and drops Questionable and Day-To-Day. This is usually what you want when the question is who is missing.
## `includeActive` (type: `boolean`):
ESPN’s feed also carries roster notes about players who are fine — depth-chart moves, contract news — under the status Active, with no injury and no return date. They are dropped by default so you are not paying for rows that are not injuries. Turn this on to get ESPN’s whole note feed.
## `statuses` (type: `array`):
Exact statuses to keep, such as Out, Questionable, Doubtful, Day-To-Day, Injured Reserve. Leave empty for all of them.
## `teams` (type: `array`):
Team names or abbreviations, such as Kansas City Chiefs or KC. Leave empty for every team.
## `positions` (type: `array`):
Positions to keep, such as QB, Quarterback, Point Guard. Leave empty for all.
## `daysAhead` (type: `integer`):
How far forward the schedule goes in Games mode. 0 means today only.
## `includePlayers` (type: `boolean`):
Teams and Games modes: include the full injured list inside each row, alongside the players who are definitely out.
## `maxItems` (type: `integer`):
Stops the run once this many rows are in the dataset.
## `proxyConfiguration` (type: `object`):
Not needed — ESPN answers Apify's own network directly. Only turn this on if your account requires all traffic through a proxy.
## Actor input object example
```json
{
"mode": "injuries",
"leagues": [
"nfl",
"nba",
"mlb",
"nhl"
],
"outOnly": false,
"includeActive": false,
"daysAhead": 7,
"includePlayers": true,
"maxItems": 5000,
"proxyConfiguration": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "injuries",
"leagues": [
"nfl",
"nba",
"mlb",
"nhl"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/sports-injuries-api").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "injuries",
"leagues": [
"nfl",
"nba",
"mlb",
"nhl",
],
}
# Run the Actor and wait for it to finish
run = client.actor("lergassy/sports-injuries-api").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 '{
"mode": "injuries",
"leagues": [
"nfl",
"nba",
"mlb",
"nhl"
]
}' |
apify call lergassy/sports-injuries-api --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/sports-injuries-api"
}
}
}
```
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 ` 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/4V1e7cPJ9d9I51Myr/builds/yQNKWC84V2m5ZIeQ9/openapi.json