# NFL Stats Scraper - Game Logs, Props, Odds & Play-by-Play (`datawright/nfl-stats-scraper`) Actor

NFL player & team game logs, box scores, player props graded over/under vs actual stats, closing lines with ATS/O-U results, schedules with odds, play-by-play, injuries, standings and rosters. Flat rows for props, DFS, fantasy and ATS models.

- **URL**: https://apify.com/datawright/nfl-stats-scraper.md
- **Developed by:** [Datawright](https://apify.com/datawright) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 row of data

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

## NFL Stats Scraper - Player Game Logs, Box Scores, Betting Lines, Player Props & More

Get clean, **analysis-ready NFL data** in one click: every player's line for every game, team game logs with **closing spread, moneyline and total plus ATS and over/under results**, schedules with **opening and current lines**, **player prop lines graded against the actual result**, play-by-play, standings and rosters.

Built for **player props, DFS, fantasy football and ATS models**, spreadsheets and AI agents. No API key, no browser, no login - fast and cheap.

### What you get

| Data type | One row per | Highlights |
|---|---|---|
| **Player game logs** | player per game | Full box score, position, opponent, home/away, W/L, starter/DNP, closing line |
| **Team game logs** | team per game | Team stats, spread, moneyline, total, **ATS result**, **O/U result** |
| **Player props** | prop line | DraftKings prop line (opening + current + movement), the actual stat and **over/under/hit/miss** result |
| **Schedule & scores** | game | Status, score, venue, TV, records, **opening vs current spread/total/moneyline** |
| **Play-by-play** | play | Period, clock, play type, text, score, players involved, down, distance, yard line, yards gained |
| **Injury report** | injured player | Status (Out/Questionable/...), injury, body part, expected return |
| **Standings** | team | Wins/losses/draws, points, goal or point differential, streak, home/road |
| **Player season stats** | player | Season totals and per-game averages |
| **Rosters** | player | Position, jersey, height, weight, age, birthplace, experience |

Every row is flat (no nested JSON), so it drops straight into Excel, Google Sheets, pandas or a database.

### Player props: lines *and* results

Most prop tools only give you today's lines. This one also grades them: for every finished game you get the DraftKings line (opening and closing), the player's actual stat, the margin and the result (**over / under / push**, or **hit / miss** for milestones and TD scorers). Pull a season to get prop **hit rates** per player, per market or per matchup - and pull upcoming games to get this week's lines.

```json
{
  "dataType": "playerProps",
  "season": "2026",
  "players": [
    "Josh Allen"
  ]
}
```

Sample prop row:

```json
{
  "league": "NFL",
  "season": "2026",
  "seasonType": "regular",
  "week": 3,
  "gameId": "401872948",
  "gameDate": "2026-09-25T00:15Z",
  "gameDateET": "2026-09-24",
  "completed": true,
  "playerId": "4036378",
  "playerName": "Jordan Love",
  "position": null,
  "team": "GB",
  "opponent": "ATL",
  "homeAway": "home",
  "market": "Total Passing Yards",
  "marketCategory": "over-under",
  "sportsbook": "DraftKings",
  "line": 235.5,
  "openLine": 232.5,
  "lineMove": 3,
  "lastUpdated": "2026-09-25T03:15Z",
  "actual": 312,
  "margin": 76.5,
  "result": "over"
}
```

### How to use

1. Pick **what data** you want.
2. Choose a **season** (e.g. `2026`) or a **date range** - or leave both empty for the most recent games.
3. Optionally filter by **teams** and **players**.
4. Run, then download as JSON, CSV or Excel, or pull it via the API.

#### Examples

Latest player box scores (great as a **daily schedule** with *Only new games* on):

```json
{
  "dataType": "playerGameLogs",
  "daysBack": 3,
  "onlyNewGames": true
}
```

Full season of team game logs with ATS and over/under results:

```json
{
  "dataType": "teamGameLogs",
  "season": "2026"
}
```

One player's game log for the season:

```json
{
  "dataType": "playerGameLogs",
  "season": "2026",
  "players": [
    "Josh Allen"
  ]
}
```

Upcoming games with betting lines:

```json
{
  "dataType": "games",
  "daysAhead": 7
}
```

### Sample output (player game log)

```json
{
  "league": "NFL",
  "season": "2026",
  "seasonType": "regular",
  "week": 3,
  "gameId": "401872948",
  "gameDate": "2026-09-25T00:15Z",
  "gameDateET": "2026-09-24",
  "status": "STATUS_FINAL",
  "completed": true,
  "neutralSite": false,
  "venue": "Lambeau Field",
  "attendance": 76955,
  "teamId": "1",
  "team": "ATL",
  "teamName": "Atlanta Falcons",
  "opponentId": "9",
  "opponent": "GB",
  "homeAway": "away",
  "teamScore": 35,
  "opponentScore": 14,
  "result": "W",
  "playerId": "4360423",
  "playerName": "Michael Penix Jr.",
  "position": null,
  "jersey": "9",
  "starter": null,
  "didNotPlay": null,
  "dnpReason": null,
  "ejected": null,
  "positionGroup": null,
  "oddsProvider": "Draft Kings",
  "spread": 4.5,
  "spreadOdds": -108,
  "moneyline": 195,
  "drawMoneyline": null,
  "total": 43.5,
  "overOdds": -105,
  "underOdds": -115,
  "passingCompletions": 18,
  "passingAttempts": 25,
  "passingYards": 256,
  "passingYardsPerPassAttempt": 10.2,
  "passingTouchdowns": 1,
  "passingInterceptions": 1,
  "passingSacks": 0,
  "passingSackYardsLost": 0,
  "passingAdjQBR": 84.5,
  "passingQBRating": 101.4,
  "rushingAttempts": 2,
  "rushingYards": -2,
  "rushingYardsPerRushAttempt": -1,
  "rushingTouchdowns": 0,
  "rushingLongRushing": -1
}
```

### Pricing

Pay only for rows you get - see the **Pricing** tab. Play-by-play and player-prop rows are priced lower because each game has hundreds of them. Use *Max rows* or the run's maximum cost to cap spending, and *Only new games* on schedules so you never pay twice for the same game.

### Automate it

- **Schedule** a daily run (Schedules → Create) with *Only new games* enabled to keep a database or spreadsheet current.
- Connect to **Google Sheets, Zapier, Make, n8n** or webhooks from the Integrations tab.
- Call it from code with the Apify API or from AI agents via the Apify MCP server.

### FAQ

**How fresh is the data?** Box scores are available minutes after a game ends; injuries, schedules and lines are fetched live on every run.

**Which betting lines are included?** The primary sportsbook line published on ESPN (usually DraftKings): closing spread, moneyline and total on game logs, and opening vs current lines on the schedule.

**What if there are no games right now?** With no dates set, the actor returns the most recent game day (or, for schedules, the next one) instead of an empty result.

**Can I get historical seasons?** Yes - set *Season* to any past season ESPN has box scores for.

### Disclaimer

This actor is not affiliated with, endorsed by or connected to ESPN, DraftKings or any league. It collects publicly available factual sports statistics. You are responsible for using the data in line with applicable terms and laws.

# Actor input Schema

## `dataType` (type: `string`):

Player game logs = one row per player per game (box-score line). Team game logs include the closing line with ATS and over/under results. Player props = sportsbook prop lines (opening + current) graded against what actually happened.

## `season` (type: `string`):

Whole-season pull, e.g. "2026". Leave empty and set dates instead (or neither for the most recent games).

## `dateFrom` (type: `string`):

YYYY-MM-DD (US Eastern game date). Overrides season.

## `dateTo` (type: `string`):

YYYY-MM-DD, inclusive. Defaults to today.

## `daysBack` (type: `integer`):

Used when no season or dates are given: finished games from the last N days (falls back to the most recent game day if there were none).

## `daysAhead` (type: `integer`):

For schedules and player props: how many upcoming days to include.

## `seasonTypes` (type: `array`):

Which parts of the season to include (ignored for soccer).

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

Team abbreviations to keep, e.g. KC, BUF. Empty = all teams.

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

Player names (partial match) or ESPN player IDs, e.g. Josh Allen. Empty = all players.

## `propMarkets` (type: `string`):

Which player prop markets to include. Milestones and TD scorers are graded hit/miss; period props are listed but not graded.

## `includeOdds` (type: `boolean`):

Adds the closing spread, moneyline (and draw for soccer) and total to game-log rows.

## `onlyNewGames` (type: `boolean`):

Skip games this account already received from a previous run - ideal for a daily schedule so you only pay for new rows.

## `stateStoreName` (type: `string`):

Named key-value store used by "Only new games". Use different names for independent schedules.

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

Stop after this many rows (0 = no limit). Pre-set to 200 so a first try stays cheap - raise it or set 0 for full pulls.

## `maxConcurrency` (type: `integer`):

Parallel requests.

## Actor input object example

```json
{
  "dataType": "playerGameLogs",
  "daysBack": 3,
  "daysAhead": 7,
  "seasonTypes": [
    "regular",
    "playin",
    "postseason"
  ],
  "propMarkets": "main",
  "includeOdds": true,
  "onlyNewGames": false,
  "maxItems": 200,
  "maxConcurrency": 6
}
```

# Actor output Schema

## `results` (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 = {
    "dataType": "playerGameLogs",
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("datawright/nfl-stats-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 = {
    "dataType": "playerGameLogs",
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("datawright/nfl-stats-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 '{
  "dataType": "playerGameLogs",
  "maxItems": 200
}' |
apify call datawright/nfl-stats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawright/nfl-stats-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/gUoV7PnT29VcAQ5ol/builds/ScxPqP6YshgprnKIC/openapi.json