# ESPN Scores, Schedules & Standings — NFL, NBA, MLB, Soccer (`spider355/espn-scores-schedules-standings`) Actor

Get game scores, upcoming fixtures, standings and team lists from ESPN for the NFL, NBA, WNBA, MLB, NHL, college football and basketball, MLS and Europe's top soccer leagues. Includes betting odds, broadcasts and venues where ESPN lists them.

- **URL**: https://apify.com/spider355/espn-scores-schedules-standings.md
- **Developed by:** [Mitchell](https://apify.com/spider355) (community)
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## ESPN Scores, Schedules & Standings — NFL, NBA, MLB, NHL, Soccer & More

Get game scores, upcoming fixtures, standings and team lists from **ESPN** for 14 leagues: NFL, NCAA football, NBA, WNBA, NCAA men's basketball, MLB, NHL, MLS, the Premier League, La Liga, Bundesliga, Serie A, Ligue 1 and the UEFA Champions League. Each game comes with status, scores, records, venue, TV channels and, where ESPN lists them, betting odds. Export as JSON, CSV or Excel, or call it as an API.

Runs are fast and need no proxies, login or API key. A default run returns yesterday's results and the next seven days of fixtures.

This Actor is not affiliated with, endorsed by or sponsored by ESPN. It reads the JSON endpoints that ESPN's own website and apps use. They are undocumented and ESPN can change or withdraw them at any time.

### What you can do with it

- **Feed a sports dashboard, newsletter or app** with results and upcoming fixtures for the leagues you follow.
- **Power a Discord or Telegram bot** that posts final scores, or alerts when your team plays. Use the team filter and schedule a run every few minutes.
- **Collect odds for betting and fantasy models**: spread, over/under and provider for upcoming games, next to each team's record.
- **Keep league tables and team directories current**: standings by conference and division, plus team names, colours and logos.

### Input

```json
{
    "leagues": ["nfl", "premier-league"],
    "dataTypes": ["games", "standings"],
    "dateFrom": "2026-10-01",
    "dateTo": "2026-10-14",
    "teamKeywords": ["chiefs", "arsenal"]
}
```

- `leagues` — one or more of the 14 leagues. Default is NFL and NBA.
- `dataTypes` — `games`, `standings`, `teams`. Default is `games`.
- `dateFrom`, `dateTo` — the days of games to return, as US Eastern calendar days (the way ESPN groups games). Leave both empty for yesterday through seven days ahead. The range is capped at 60 days; a longer range is cut to 60 days from `dateFrom` and the cut is noted in the run summary.
- `teamKeywords` — keep only games, standings rows and teams where a team's name, location or abbreviation contains one of these words (case-insensitive).

Standings and teams are the current-season snapshot and ignore the dates.

### Output

One dataset, with a `type` field of `game`, `standing` or `team`. Every item has every field, and fields that do not apply to its type are `null`, so the data exports cleanly to CSV. Home and away teams are flattened into `homeTeamName`, `homeScore`, `awayTeamName`, `awayScore` and so on.

A game (the empty standing and team fields are left out here):

```json
{
    "type": "game",
    "league": "nfl",
    "leagueName": "NFL",
    "sport": "football",
    "scrapedAt": "2026-10-05T19:50:35.906Z",
    "gameId": "401872979",
    "name": "Atlanta Falcons at New Orleans Saints",
    "shortName": "ATL @ NO",
    "startTime": "2026-10-06T00:15:00.000Z",
    "status": "scheduled",
    "statusDetail": "Mon, October 5th at 8:15 PM EDT",
    "period": null,
    "clock": null,
    "seasonYear": 2026,
    "seasonType": "regular-season",
    "week": 4,
    "homeTeamId": "18",
    "homeTeamName": "New Orleans Saints",
    "homeTeamAbbreviation": "NO",
    "homeScore": null,
    "homeWinner": null,
    "homeRecord": "1-2",
    "awayTeamId": "1",
    "awayTeamName": "Atlanta Falcons",
    "awayTeamAbbreviation": "ATL",
    "awayScore": null,
    "awayWinner": null,
    "awayRecord": "1-2",
    "venueName": "Caesars Superdome",
    "venueCity": "New Orleans",
    "broadcasts": ["ESPN"],
    "headline": null,
    "notes": [],
    "oddsDetails": "NO -1.5",
    "spread": -1.5,
    "overUnder": 47.5,
    "oddsProvider": "Draft Kings",
    "gameUrl": "https://www.espn.com/nfl/game/_/gameId/401872979/falcons-saints"
}
```

- `status` is `scheduled`, `in progress`, `final`, `postponed`, `canceled`, `delayed` and similar. `statusDetail` is ESPN's own text, such as "Final/OT".
- Scores are `null` before a game starts. `homeWinner` and `awayWinner` are `null` until it is final, and both are `false` for a drawn soccer match.
- `headline` is ESPN's recap headline once a game has one. `notes` holds labels such as "ALDS - Game 1".
- Standing rows carry `group` (conference and division), `rank`, `wins`, `losses`, `ties`, `gamesPlayed`, `winPercent`, `points` (soccer and hockey), `pointsFor`, `pointsAgainst`, `pointDifference` (goal difference in soccer), `streak` and `record`.
- Team rows carry `teamId`, `teamName`, `teamAbbreviation`, `teamLocation`, `teamNickname`, `color`, `alternateColor`, `logoUrl` and `teamUrl`.

The `SUMMARY` record in the key-value store lists, for each league and data type, the number of items returned or the error. One league failing does not stop the others.

This Actor covers teams and leagues only. It does not return individual player data.

### Pricing

You pay per result returned.

### Limits worth knowing

- Scores are a snapshot from the moment the run reads ESPN, shown in `scrapedAt`. For near-live updates, schedule runs at the interval you need.
- ESPN does not list odds for every game, and usually not for finished games. `oddsDetails`, `spread`, `overUnder` and `oddsProvider` are `null` when there are none.
- `week` is filled only for leagues that use weeks, such as the NFL and college football. `period` and `clock` are mostly empty for soccer.
- `seasonYear` is the year ESPN gives the season, which for leagues that span two calendar years is the later one (the 2026-27 NBA season is 2027).
- ESPN does not accept a date range on this endpoint, so the Actor reads one month at a time (or one day at a time for NCAA men's basketball and very busy months) and trims to your range. A 60-day run makes at most a few requests per league, a little more for NCAA men's basketball.
- NCAA football games and standings cover the top division (FBS). NCAA men's basketball covers all of Division I, so its standings and team lists are large.
- Standings are grouped by division where ESPN splits them (NFL, NBA, NHL, MLB), otherwise by conference or by the whole league table.
- ESPN's endpoints are undocumented. If ESPN changes them, the Actor may need an update. Please report it.

### Questions and requests

Open an issue on the Issues tab and it will be looked at quickly.

# Actor input Schema

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

Which leagues to read.

## `dataTypes` (type: `array`):

Games covers scores and upcoming fixtures for the date range. Standings and teams are current-season snapshots and ignore the dates.

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

First day of games to return, in US Eastern time (YYYY-MM-DD). Leave empty to start yesterday.

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

Last day of games to return, in US Eastern time (YYYY-MM-DD). Leave empty to end 7 days ahead. The range is capped at 60 days.

## `teamKeywords` (type: `array`):

Keep only games, standings rows and teams whose team name or abbreviation contains one of these words, such as Lakers, Chiefs or ARS. Leave empty for everything.

## Actor input object example

```json
{
  "leagues": [
    "nfl",
    "nba"
  ],
  "dataTypes": [
    "games"
  ]
}
```

# Actor output Schema

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

One item per game, standings row or team. The type field says which.

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

Per league and data type: items returned, or the error.

# 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"
    ],
    "dataTypes": [
        "games"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider355/espn-scores-schedules-standings").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",
    ],
    "dataTypes": ["games"],
}

# Run the Actor and wait for it to finish
run = client.actor("spider355/espn-scores-schedules-standings").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"
  ],
  "dataTypes": [
    "games"
  ]
}' |
apify call spider355/espn-scores-schedules-standings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spider355/espn-scores-schedules-standings"
        }
    }
}
```

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/oPJiazikyCVS0RCpd/builds/HgmtY00tvmzNBqvZX/openapi.json