# ESPN Sports Data Scraper – Scores, Schedules, Standings & Odds (`rowfeed/espn-sports-data-scraper`) Actor

Extract ESPN sports data: live scores, schedules, standings, teams and box scores for NFL, NBA, MLB, NHL, college sports, top soccer leagues and UFC. Clean JSON for bettors, odds modellers, fantasy apps and AI agents.

- **URL**: https://apify.com/rowfeed/espn-sports-data-scraper.md
- **Developed by:** [Rowfeed](https://apify.com/rowfeed) (community)
- **Categories:** Sports, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 games

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?

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

## ESPN Sports Data Scraper – Scores, Schedules, Standings & Odds

Get ESPN's live scores, schedules, standings, team lists and box scores as clean JSON rows, across NFL, NBA, MLB, NHL, college football and basketball, WNBA, the top five European soccer leagues, MLS, the Champions League and UFC.
Built for bettors and odds modellers, fantasy apps, sports media, dashboards and AI agents that need reliable sports data without a login, an API key or a headless browser.
Plain HTTPS calls to ESPN's own public API with retries and a silent-failure check, so a scheduled run keeps working when ESPN hiccups.

### What you get

- **Games** – date, status, venue, home/away teams and scores, winner, broadcast network and, when a sportsbook has posted a line, the spread, over/under and moneylines.
- **Standings** – wins, losses, ties, win percentage, points for/against, streak and rank per team, grouped by conference or table.
- **Teams** – every team's ID, name, abbreviation, location, colors and logo.
- **Game summaries** – box score totals per team (line by period/inning), statistical leaders, odds and a play-by-play list (capped at 500 plays).

### Sample row

One NFL game from the default run:

```json
{
  "type": "game",
  "league": "nfl",
  "sport": "football",
  "event_id": "401872656",
  "name": "New England Patriots at Seattle Seahawks",
  "short_name": "NE @ SEA",
  "date": "2026-09-10T00:20Z",
  "status": "STATUS_SCHEDULED",
  "status_detail": "Wed, September 9th at 8:20 PM EDT",
  "home_team": "Seattle Seahawks",
  "home_abbrev": "SEA",
  "home_score": 0.0,
  "away_team": "New England Patriots",
  "away_abbrev": "NE",
  "away_score": 0.0,
  "winner": null,
  "broadcast": "NBC",
  "url": "https://www.espn.com/nfl/game/_/gameId/401872656/patriots-seahawks",
  "odds_provider": "DraftKings",
  "spread": -3.0,
  "over_under": 44.5,
  "home_moneyline": -166.0,
  "away_moneyline": 140.0,
  "scraped_at": "2026-09-09T16:27:19+00:00"
}
```

### Supported leagues

| Input key | League |
|---|---|
| `nfl` | NFL |
| `college-football` | NCAA football |
| `nba` | NBA |
| `wnba` | WNBA |
| `mens-college-basketball` | NCAA men's basketball |
| `mlb` | MLB |
| `nhl` | NHL |
| `eng.1` | English Premier League |
| `esp.1` | La Liga |
| `ger.1` | Bundesliga |
| `ita.1` | Serie A |
| `fra.1` | Ligue 1 |
| `usa.1` | MLS |
| `uefa.champions` | UEFA Champions League |
| `ufc` | UFC |

### Input

| Field | Default | What it does |
|---|---|---|
| `leagues` | `["nfl","nba","mlb","nhl"]` | Which leagues to pull, from the table above. |
| `dataType` | `scoreboard` | `scoreboard`/`schedule` (games), `standings`, `teams`, or `summary` (box score per event ID). |
| `dateFrom` / `dateTo` | today / same as `dateFrom` | Date range (YYYY-MM-DD) for scoreboard/schedule. Capped at 31 days. |
| `eventIds` | `[]` | Event IDs to summarize (from a scoreboard row's `event_id`). Only used by `summary`. |
| `maxEvents` | `200` | Row cap; each row is one charged event. |
| `includeOdds` | `true` | Include spread/over-under/moneyline columns on game rows when a sportsbook has posted a line. |

### Pricing

Pay per event, no subscription: **$1 per 1,000 games**, **$0.50 per 1,000 standings or teams**, **$5 per 1,000 game summaries**. A default run (16 games today) costs about $0.016. Set a maximum charge on the run and the Actor stops cleanly when it is reached.

### Use it from your tools

- **API and SDKs** – call it via the Apify API or the official Python/JavaScript clients: one call to start the run, one to fetch the dataset as JSON or CSV.
- **Schedules** – run it hourly or daily inside Apify and push new scores or standings to Google Sheets, a webhook or your own storage automatically.
- **n8n, Make and Zapier** – trigger runs and pipe game data into a workflow through Apify's integration for each.
- **AI agents and MCP** – this Actor is eligible for agentic use via Apify's MCP server and supports pay-per-event pricing, so an agent can call it mid-task and pay only per game, standing or team it actually reads.
- **Webhooks** – fire on run finished to kick off the next step in a pipeline as soon as fresh scores land.

### Details

- **Source**: ESPN's public site API (`site.api.espn.com`). No authentication. Requests use a generic client User-Agent — ESPN's edge blocks branded/browser-style User-Agent strings, so this Actor doesn't spoof one, it just doesn't send a distinguishing header.
- **Reliability**: 429 and 5xx responses are retried with exponential backoff (5 tries); a 200 without the expected data counts as a failure. One bad league or event never stops the run — it becomes an error row and the rest continues. A run fails only when it produced no rows *and* hit errors; no games today for a league is a successful, empty result for that league.
- **Run stats**: the `STATS` record in the run's key-value store holds request and error counts per category (`network`, `rate_limit`, `blocked`, `not_found`, `other`).
- **Standings coverage varies by sport**: American leagues expose win percentage, games back and streak; soccer leagues expose league points and rank instead. Missing fields are `null`, not an error.
- **Output**: one dataset row per game, standing, team or summary, tagged with a `type` column. The Overview table shows type, league, name, date, status, scores, spread and over/under. Export as JSON, CSV or Excel, fetch through the Apify API, or schedule runs into Google Sheets, Make, Zapier or your own code.

Not affiliated with ESPN.

# Actor input Schema

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

Leagues to scrape. Supported: nfl, college-football, nba, wnba, mens-college-basketball, mlb, nhl, eng.1 (Premier League), esp.1 (La Liga), ger.1 (Bundesliga), ita.1 (Serie A), fra.1 (Ligue 1), usa.1 (MLS), uefa.champions, ufc.

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

scoreboard/schedule return games for the date range below. standings returns the league table. teams returns the team list. summary returns a box score for each event ID.

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

Start date as YYYY-MM-DD. Empty = today (UTC). Used by scoreboard and schedule.

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

End date as YYYY-MM-DD. Empty = same as "Date from". Ranges are capped at 31 days.

## `eventIds` (type: `array`):

ESPN event IDs to summarize, e.g. from a scoreboard row's event\_id. Only used when dataType is summary.

## `maxEvents` (type: `integer`):

Keep at most this many rows (games, standings, teams or summaries). Each row is one charged event.

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

Include odds/spread/over-under/moneyline fields from the scoreboard when a sportsbook has posted a line.

## Actor input object example

```json
{
  "leagues": [
    "nfl",
    "nba",
    "mlb",
    "nhl"
  ],
  "dataType": "scoreboard",
  "dateFrom": "",
  "dateTo": "",
  "eventIds": [
    "401872656"
  ],
  "maxEvents": 200,
  "includeOdds": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rowfeed/espn-sports-data-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rowfeed/espn-sports-data-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 '{}' |
apify call rowfeed/espn-sports-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rowfeed/espn-sports-data-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/eow9Nbe8PUQmoCoC7/builds/UdXxBLQCs9gCoE1ek/openapi.json