# Sports Scores & Schedules API — NFL, NBA, MLB, NHL, Soccer (`insight.solutions/sports-scores-api`) Actor

Scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, WNBA, college sports, 30+ soccer leagues, F1 and more, as clean rows from ESPN's public feed. Odds, venues, broadcasts, records. No API key, no player data. $0.80 per 1,000 games.

- **URL**: https://apify.com/insight.solutions/sports-scores-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Other, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 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.
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?

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 Scores & Schedules API — NFL, NBA, MLB, NHL, Soccer

Scores, schedules, standings, teams and headlines for **any league ESPN
covers** — the NFL, NBA, MLB, NHL, WNBA, college football and basketball, 33
soccer competitions from the Premier League to the Champions League, F1, NASCAR,
golf, tennis and the UFC — as **clean, flat rows in one schema**. Live and final
scores, status, records, venues, broadcasts and the public pre-game line on
every game. No API key, no login, no browser.

> **Where the data comes from.** This Actor reads ESPN's public site API
> (`site.api.espn.com`) — an **unofficial, public JSON feed**: keyless,
> undocumented, used by many tools and stable for years, but **the format may
> change** without notice. This Actor is **not affiliated with ESPN, any league
> or any team**. It returns **no player data**: teams, games, scores, venues,
> records, odds and standings only.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "leagues": ["nfl", "nba"], "mode": "scoreboard" }
```

Every game on today's NFL and NBA slates, in two requests. Two leagues, so
that one of them is always in season. Change `mode` for the
other four: `schedule`, `standings`, `teams`, `news`.

**Output** — one row per game; the fields you will use most are `startTime`,
`name`, `status`, `homeTeam`, `homeScore`, `awayTeam`, `awayScore`, `venue`,
`broadcasts` and `spread` (full list under *Output reference*). Standings,
teams and headlines come back on the same columns. Anything that could not be
read comes back as a free diagnostic row (`rowType: "diagnostic"`, `errorType`,
`error`) instead of a charge.

**Price** — **$0.80 per 1,000 games** on the FREE tier (standings rows and teams
$0.0004, headlines $0.0003, + $0.001 per run, charged only once a run has
returned something). League summary rows, diagnostic rows, a league that is out
of season and a request ESPN refused are all free, and a run that returns
nothing bills nothing at all. Pay-per-event, limited permissions — works over
the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments.

**From code** —
`client.actor("insight.solutions/sports-scores-api").call(run_input={…})` with
`apify-client`, or `POST
https://api.apify.com/v2/acts/insight.solutions~sports-scores-api/run-sync-get-dataset-items`.

***

### What you get

One row per game. Same columns whatever the league.

A **game** that has not started yet (the NFL's Monday night game, 2026-10-05):

```json
{
  "rowType": "game",
  "league": "nfl",
  "sport": "football",
  "gameId": "401872979",
  "season": 2026,
  "seasonType": "regular-season",
  "week": 4,
  "startTime": "2026-10-06T00:15:00.000Z",
  "startTimeLocal": "Mon, October 5th at 8:15 PM EDT",
  "name": "Atlanta Falcons at New Orleans Saints",
  "shortName": "ATL @ NO",
  "eventType": "game",
  "status": "scheduled",
  "completed": false,
  "homeTeam": "New Orleans Saints",
  "homeAbbr": "NO",
  "homeScore": null,
  "homeRecord": "1-2",
  "awayTeam": "Atlanta Falcons",
  "awayAbbr": "ATL",
  "awayScore": null,
  "awayRecord": "1-2",
  "venue": "Caesars Superdome",
  "venueCity": "New Orleans",
  "venueState": "LA",
  "indoor": true,
  "broadcasts": ["ESPN"],
  "spread": "NO -1.5",
  "overUnder": 47.5,
  "oddsProvider": "DraftKings",
  "weather": "Cloudy",
  "temperatureF": 79,
  "url": "https://www.espn.com/nfl/game/_/gameId/401872979/falcons-saints"
}
```

The same game once it is over carries the score, the winner and the gate — here
Chiefs at Raiders the day before:

```json
{
  "rowType": "game",
  "gameId": "401872976",
  "name": "Kansas City Chiefs at Las Vegas Raiders",
  "status": "final",
  "statusDetail": "Final",
  "period": 4,
  "homeAbbr": "LV",
  "homeScore": 27,
  "homeRecord": "3-1",
  "awayAbbr": "KC",
  "awayScore": 30,
  "awayRecord": "4-0",
  "winnerTeamId": "12",
  "attendance": 62593,
  "broadcasts": ["CBS"]
}
```

A **standings** line, with every stat ESPN lists kept in `stats`:

```json
{
  "rowType": "standing",
  "league": "nfl",
  "season": 2026,
  "group": "American Football Conference",
  "teamId": "12",
  "team": "Kansas City Chiefs",
  "abbr": "KC",
  "rank": 1,
  "wins": 4,
  "losses": 0,
  "ties": 0,
  "winPercent": 1,
  "gamesBehind": 0,
  "pointsFor": 118,
  "pointsAgainst": 77,
  "pointDifferential": 41,
  "streak": "W4",
  "stats": { "W": "4", "L": "0", "PCT": "1.000", "SEED": "1", "Home": "2-0", "Road": "2-0", "vs. Div.": "2-0", "…": "…" }
}
```

A **team**:

```json
{
  "rowType": "team",
  "league": "nba",
  "teamId": "1",
  "team": "Atlanta Hawks",
  "abbr": "ATL",
  "location": "Atlanta",
  "nickname": "Hawks",
  "slug": "atlanta-hawks",
  "color": "c8102e",
  "logoUrl": "https://a.espncdn.com/i/teamlogos/nba/500/atl.png",
  "url": "https://www.espn.com/nba/team/_/name/atl/atlanta-hawks"
}
```

A **headline**:

```json
{
  "rowType": "article",
  "league": "nfl",
  "articleId": "50112291",
  "headline": "McVay: Rams coaches will 'learn' from incident with Eagles fans",
  "summary": "Rams coach Sean McVay says his assistant coaches will learn from their viral interaction with Eagles fans during Sunday's win over Philadelphia.",
  "publishedAt": "2026-10-05T22:32:59.000Z",
  "url": "https://www.espn.com/nfl/story/_/id/50112291/mcvay-rams-coaches-learn-incident-eagles-fans",
  "imageUrl": "https://a.espncdn.com/photo/2026/1005/r1726550_600x400_3-2.jpg",
  "categories": ["NFL", "Los Angeles Rams", "Philadelphia Eagles"]
}
```

And one free **league** row per league per run, saying what ESPN listed and
what came back: `leagueName`, `season`, `seasonType`, `week`, `games` (on the
slate, before any filter) and `returned`.

***

### Quick start

| You want | Input |
|---|---|
| Today's games in the four US majors | `{ "leagues": ["nfl", "nba", "mlb", "nhl"] }` |
| Saturday's Premier League and LALIGA fixtures | `{ "leagues": ["eng.1", "esp.1"], "dates": ["2026-10-10"] }` |
| A week of MLB results | `{ "leagues": ["mlb"], "dates": ["2026-09-21..2026-09-27"] }` |
| Only what is still to play today | `{ "leagues": ["nfl"], "includeCompleted": false }` |
| The Lakers' season | `{ "mode": "schedule", "leagues": ["nba"], "teams": ["LAL"] }` |
| Two teams in two leagues | `{ "mode": "schedule", "leagues": ["nba", "nfl"], "teams": ["nba:LAL", "nfl:KC"] }` |
| The NFL and NBA tables | `{ "mode": "standings", "leagues": ["nfl", "nba"] }` |
| Last season's Premier League table | `{ "mode": "standings", "leagues": ["eng.1"], "season": 2025 }` |
| Every WNBA team, with logos and colours | `{ "mode": "teams", "leagues": ["wnba"] }` |
| The latest ten NFL headlines | `{ "mode": "news", "leagues": ["nfl"], "maxArticles": 10 }` |
| This weekend's Grand Prix | `{ "leagues": ["f1"] }` |

***

### League slugs

The ones people use most. The full table (51 leagues) is bundled in
`src/leagues.json`.

| Slug | League | Also accepts |
|---|---|---|
| `nfl` | NFL | `football/nfl` |
| `college-football` | NCAA Football (FBS) | `ncaaf`, `cfb` |
| `nba` | NBA | `basketball/nba` |
| `wnba` | WNBA | |
| `mens-college-basketball` | NCAA Men's Basketball | `ncaab`, `ncaam` |
| `womens-college-basketball` | NCAA Women's Basketball | `ncaaw` |
| `mlb` | MLB | |
| `college-baseball` | NCAA Baseball | |
| `nhl` | NHL | |
| `eng.1` | English Premier League | `epl`, `premier-league` |
| `eng.2` | English League Championship | `championship` |
| `esp.1` | Spanish LALIGA | `laliga` |
| `ger.1` | German Bundesliga | `bundesliga` |
| `ita.1` | Italian Serie A | `serie-a` |
| `fra.1` | French Ligue 1 | `ligue-1` |
| `usa.1` | MLS | `mls` |
| `mex.1` | Liga MX | `liga-mx` |
| `uefa.champions` | UEFA Champions League | `champions-league`, `ucl` |
| `uefa.europa` | UEFA Europa League | `europa-league` |
| `fifa.world` | FIFA World Cup | `world-cup` |
| `f1` | Formula 1 | `formula-1` |
| `nascar-premier` | NASCAR Cup Series | `nascar` |
| `pga` | PGA Tour | |
| `atp` / `wta` | ATP and WTA tennis | |
| `ufc` | UFC | |

Every soccer slug in the table is one ESPN itself lists — it lists 219 soccer
competitions in all. **Any ESPN path works too**: `soccer/arg.1`,
`soccer/bra.1`, or anything else of the form `<sport>/<league>` for a sport in
the table is passed through as written. A slug the Actor does not recognise
comes back as a free `league-not-found` row naming the three nearest
(`"nfll"` → `nfl`).

***

### Modes

| `mode` | Reads | Rows | Requests |
|---|---|---|---|
| `scoreboard` *(default)* | Each league's current slate, or the `dates` you give | `game` | one per league per day |
| `schedule` | A team's season — needs `teams` | `game` | one team list per league, then one per team |
| `standings` | The league table, by conference or group | `standing` | one per league |
| `teams` | Every team in the league | `team` | one per league |
| `news` | The latest headlines | `article` | one per league |

**Races and tournaments.** An F1, NASCAR or IndyCar weekend is one row with
`eventType: "race"`; a golf or tennis tournament or a UFC card is one row with
`eventType: "tournament"`. Their name, dates, status, venue (the circuit, for a
race) and broadcasts are there; their competitors are individual athletes and
are not — see *No player data*. For the same reason `schedule`, `standings` and
`teams` are not available for those sports, and asking for them returns a free
`unsupported` row.

**Teams for `schedule`** are ids or abbreviations (`13`, `LAL`; full names like
`Los Angeles Lakers` work too), resolved through the league's team list, which
is read once. With more than one league, scope an entry as `nba:LAL` — `13` is
the Lakers in the NBA and the Raiders in the NFL, and an unscoped entry is
tried in every league you list. A game between two teams you asked for is
returned once. The schedule is the season type ESPN currently serves for that
team — during the preseason, the preseason games.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `leagues` | string\[] | `["nfl", "nba"]` | Slugs, aliases or ESPN paths (see *League slugs*) |
| `mode` | enum | `scoreboard` | `scoreboard`, `schedule`, `standings`, `teams`, `news` |
| `dates` | string\[] | `[]` | `scoreboard` only. `2026-10-05` or `2026-10-01..2026-10-07`; at most 31 days per range; empty = the current slate |
| `teams` | string\[] | `[]` | `schedule` only. `13`, `LAL`, `nba:LAL` |
| `season` | int | — | `schedule` and `standings`: `?season=` as ESPN numbers it (2026-27 NBA is `2027`, 2026-27 Premier League is `2026`) |
| `includeOdds` | bool | `true` | `spread`, `overUnder`, `oddsProvider` on game rows |
| `includeCompleted` | bool | `true` | Off = upcoming and live games only; finished games are dropped before the charge |
| `maxGamesPerLeague` | int | 200 | Across all of a league's dates or teams |
| `maxArticles` | int | 20 | `news`: headlines per league, sent as `?limit=` |
| `maxConcurrency` | int | 4 | Leagues read at once; never more than four requests in flight |
| `maxRunSecs` | int | 240 | Time budget, max 3600 |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify datacenter |

Inputs that belong to another mode are ignored, not errors. An input with
nothing usable in it — no league the Actor knows, a `schedule` run with no team,
`dates` none of which is a date — finishes FAILED before a single request is
sent, with a free row saying why.

***

### Output reference

`rowType` is one of six. Four are charged, two are free.

| `rowType` | Charged | What it is |
|---|---|---|
| `game` | yes | A game, race or tournament: status, score, teams, venue, broadcasts, line |
| `standing` | yes | One team's line in a league table |
| `team` | yes | One team |
| `article` | yes | One headline |
| `league` | **no** | One per league per run: what ESPN listed and what came back |
| `diagnostic` | **no** | Anything that could not be read, and why |

Every row carries `ok`, `rowType`, `input`, `error`, `errorType`, `scrapedAt`,
`source` (`site.api.espn.com`), `sourceUrl` (the exact API URL) and `null` in
every column that does not apply — so a CSV export is one rectangular table
however the run was configured.

#### Game columns, normalised

- **`status`** is one of six: `scheduled`, `in_progress`, `final`,
  `postponed`, `canceled`, `delayed`, mapped from ESPN's `STATUS_*` names
  (halftime and the break between periods are `in_progress`). `statusDetail`
  keeps ESPN's own line — "Final", "Final/OT", the period and clock.
- **Scores** are numbers on scoreboards and schedules alike (ESPN writes them
  as `"27"` on one and `{ "value": 27 }` on the other), and **null before a
  game starts** — ESPN prints `0`, which would read as a nil-nil.
- **`startTime`** is ISO 8601 UTC. **`startTimeLocal`** is ESPN's own text for
  a game not yet started ("Mon, October 5th at 8:15 PM EDT" — US Eastern in
  every capture).
- **`homeRecord` / `awayRecord`** are the season record. In the MLB postseason
  ESPN also attaches the *series* record; that one is not used.
- **`clock`** only while a game is live; **`period`** once it has started;
  **`attendance`** once it has been played.

#### The pre-game line

With `includeOdds` on, `spread`, `overUnder` and `oddsProvider` are **the
public pre-game line ESPN lists, exactly as it lists it** — informational, not
advice. `spread` is ESPN's own line text: a point spread for football and
basketball (`"NO -1.5"`), and for hockey and soccer the moneyline ESPN shows in
the same place (`"TB -218"`, `"ARS -260"`). Finished games usually carry no
line at all.

#### Standings columns

`rank` is ESPN's rank where it gives one, else the playoff seed, else the
line's place in the table — the NFL table is sorted by win percentage, not by
seed. `wins`, `losses`, `ties`, `winPercent`, `gamesBehind`, `pointsFor`,
`pointsAgainst`, `pointDifferential` and `streak` are pulled out as columns;
`stats` keeps **every** stat ESPN lists, abbreviation to display value, with
the splits that have no abbreviation (`Home`, `Road`, `vs. Div.`) keyed by name.
`group` is the conference, division or table.

#### Diagnostic rows

`errorType` is one of `league-not-found`, `team-not-found`, `no-games`,
`no-results`, `not-found`, `unsupported`, `invalid-input`, `truncated`,
`blocked`, `timeout`, `unavailable`. None of them is ever charged for. A run
whose input was usable but produced only these — a league out of season, a team
ESPN does not list, a request ESPN refused — finishes **SUCCEEDED with zero
results**, a status message that says so, and a free row per problem telling
you why; nothing is charged, start fee included.

***

### No player data

This Actor returns **teams, games, scores, venues, records, odds and standings
only — no player data**. ESPN's payloads are full of people: game leaders with
names, headshots and jersey numbers, winning and losing pitchers, goal scorers,
the drivers in a race, rosters, and a byline on every article. None of it is
emitted. Every column is built field by field from a named path and nothing is
passed through, so there is no `athlete`, `leaders` or `byline` field anywhere
in the dataset; the offline suite collects every athlete name in every captured
payload and checks that none of them reaches a row.

The one place a person can still be named is ESPN's own editorial text: a
headline such as "Cowboys' Tyler Smith hoping to be ready to face Bucs" *is* the
headline, and it is returned as written. An article's `categories` list the
leagues and teams it is filed under, never the players or the writer.

***

### Being a good citizen

The feed is free and public, which is a reason to be careful with it:

- **Each scoreboard is polled once per run.** ESPN serves it with
  `cache-control: max-age=6`; asking twice in one run would be asking for the
  same answer. Two spellings of one league, overlapping date ranges and a team
  list needed by several team entries are all one request.
- **Never more than four requests in flight, started at least 200 ms apart**,
  across the whole run, whatever `maxConcurrency` says; and a 250–600 ms pause
  between successive requests for one league (the days of a range, the teams of
  a schedule).
- Requests carry an ordinary browser `User-Agent`: ESPN's CDN answers HTTP 403
  to any other string, so a self-naming one is not an option here.
- A 403 or 429 is a block: the proxy session is rotated once, and a second
  refusal becomes a free `blocked` row rather than a retry loop.

***

### What you are never charged for

- The `league` row, one per league per run.
- Every `diagnostic` row.
- A league with no games on the dates asked for — out of season, an off day.
- Finished games dropped by `includeCompleted: false`, games past
  `maxGamesPerLeague`, and a game already returned for another date or team.
- Leagues and teams the Actor or ESPN does not know.
- Requests that were blocked, failed or timed out.
- A run that returns nothing at all: it finishes **SUCCEEDED with zero
  results** and a "0 results" status message, and bills nothing, **start fee
  included**.

***

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the run has returned a paid row | $0.001 | $0.001 | $0.001 | $0.001 |
| **`game`** | One game, race or tournament | **$0.0008** | **$0.0008** | **$0.00064** | **$0.00048** |
| `standing` | One standings line | $0.0004 | $0.0004 | $0.00032 | $0.00024 |
| `team` | One team | $0.0004 | $0.0004 | $0.00032 | $0.00024 |
| `article` | One headline | $0.0003 | $0.0003 | $0.00024 | $0.00018 |

**$0.80 per 1,000 games.**

| Run | Cost |
|---|---|
| Today's NFL + NBA slates, about 30 games | **≈ $0.025** ($0.0266 for 32) |
| One team's full NFL regular season, 17 games | **$0.0146** |
| NFL + NBA standings, 62 lines | **$0.0258** |
| All 30 NBA teams | **$0.013** |
| 20 NFL headlines | **$0.007** |
| A league that is out of season | **$0.00** |

Charging is charge-after-push: rows are in your dataset before the event is
recorded. `ACTOR_MAX_TOTAL_CHARGE_USD` is respected — the run stops fetching when
it is reached and finishes SUCCEEDED saying so.

***

### Proxy

The default is `{ "useApifyProxy": true }` — Apify's **datacenter** pool, which
is what the capture this Actor was built on came through. You can switch to
residential if your runs start getting blocked; you will not get different
data.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions**, uses **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~sports-scores-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"leagues":["nfl","eng.1"],"mode":"scoreboard","includeCompleted":false}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/sports-scores-api").call(run_input={
    "leagues": ["nba", "nhl"],
    "dates": ["2026-10-20..2026-10-26"],
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("ok") and row["rowType"] == "game":
        print(row["startTime"], row["shortName"], row["status"],
              row["awayScore"], row["homeScore"], row["venue"], sep=" | ")
```

Schedule it hourly on game days for a cheap scores feed: each run reads every
scoreboard once, and an idle league costs nothing.

***

### FAQ

**Do I need an API key?**
No. The feed is public and keyless, and this Actor sends no cookies and no
credentials of anybody's.

**Is this real-time?**
Each run reads ESPN's scoreboard as it stands at that moment, which ESPN itself
caches for six seconds. A run is a snapshot; for a live ticker, schedule runs.

**Why is `homeScore` null for a game that has not started?**
Because it has no score. ESPN prints `0` there, and a column that read `0-0`
before kickoff would be wrong in every aggregate you built on it.

**Why is `spread` a moneyline for hockey and soccer?**
Because that is what ESPN shows in that place for those sports, and the column
is "the line ESPN lists", copied as-is rather than reinterpreted.

**Why can't I get F1 standings or a tennis draw?**
Because they are tables of drivers and players, and this Actor returns no
player data. Race weekends and tournaments are on the scoreboard as rows of
their own.

**What happens out of season?**
The league's scoreboard is empty, and you get a free `no-games` row for it and
nothing billed. The run still SUCCEEDS. Pass `dates` to read a past or future
day.

**What happens if the format changes?**
The feed is unofficial and can change. If a response stops parsing, the run
returns a free diagnostic row naming the request rather than a wrong number. A
run that returned no real row finishes SUCCEEDED with zero results and a
"0 results" status message pointing at those rows, and bills nothing.

**Is this affiliated with ESPN or the leagues?**
No. It reads a public feed and links back to every game and story on espn.com.
It is not affiliated with, endorsed by or connected to ESPN, any league or any
team.

***

### Limitations

- **The upstream format may change.** ESPN's site API is undocumented and
  unofficial; it has been stable for years, and that is all anyone can say.
- **No player data, by design** — no leaders, box scores, rosters, player stats,
  drivers or bylines. Headlines are ESPN's text and may name people.
- **One snapshot per run.** Each scoreboard is read once; nothing is polled.
- **A schedule is the season type ESPN currently serves.** During the
  preseason a team's schedule is its preseason games.
- **College football is the FBS slate.** The scoreboard is asked for FBS
  (`groups=80`, up to 100 games a day); FCS and lower divisions are not
  included.
- **Soccer outside the table needs its ESPN path** (`soccer/arg.1`). ESPN lists
  219 competitions; 33 of them have a slug here.
- **Standings and team lists for the less-covered leagues** (college sports,
  minor soccer competitions) have not been checked against a capture; if ESPN
  has none, the row says so for free.

***

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

Which leagues to read, e.g. `["nfl", "nba"]`. Slugs: `nfl`, `college-football`, `nba`, `wnba`, `mens-college-basketball`, `womens-college-basketball`, `mlb`, `college-baseball`, `nhl`, soccer leagues by ESPN's own code (`eng.1` Premier League, `esp.1` LALIGA, `ger.1` Bundesliga, `ita.1` Serie A, `fra.1` Ligue 1, `usa.1` MLS, `uefa.champions` Champions League and about thirty more), `f1`, `nascar-premier`, `pga`, `atp`, `wta`, `ufc`. Aliases such as `epl`, `mls` and `ncaaf` work, and so does ESPN's full path (`football/nfl`, `soccer/arg.1`). An unknown slug comes back as a free row naming the nearest ones.

## `mode` (type: `string`):

What to read. `scoreboard` is each league's games for today (or for the dates you give). `schedule` is a team's season — it needs `teams`. `standings` is the league table. `teams` is every team in the league. `news` is the latest headlines. Inputs that belong to other modes are ignored, not errors.

## `dates` (type: `array`):

For `scoreboard`: the days to read, as `2026-10-05` or an inclusive range `2026-10-01..2026-10-07`. One request per league per day; a range is read for at most 31 days. Leave empty for each league's current slate.

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

For `schedule`: team ids or abbreviations, e.g. `["LAL"]` or `["13"]`, resolved through the league's team list. When you list several leagues, scope an entry as `nba:LAL` — `13` is the Lakers in the NBA and the Raiders in the NFL.

## `season` (type: `integer`):

For `schedule` and `standings`: the season year, sent as `?season=`. ESPN's numbering varies by league: in the captures the 2026-27 NBA and NHL seasons are `2027` while the 2026-27 Premier League is `2026` — the `season` column on any row shows the number ESPN uses. Leave empty for the current season.

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

Add `spread`, `overUnder` and `oddsProvider` to game rows: the public pre-game line ESPN lists, exactly as it lists it. Informational only.

## `includeCompleted` (type: `boolean`):

Return games that have already finished. Turn it off for upcoming and live games only; finished games are then dropped before anything is charged.

## `maxGamesPerLeague` (type: `integer`):

The most game rows one league may return in this run, across all its dates or teams.

## `maxArticles` (type: `integer`):

For `news`: how many headlines to ask for per league (sent as `?limit=`).

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

How many leagues to read at once. The Actor never has more than four requests in flight and starts them at least 200 ms apart, whatever you set here.

## `maxRunSecs` (type: `integer`):

Stop after this many seconds. Rows already returned are kept and charged; nothing else is.

## `proxyConfiguration` (type: `object`):

The feed answered through the Apify datacenter proxy when it was captured, so that is the default. Switch to residential only if your runs start getting blocked.

## Actor input object example

```json
{
  "leagues": [
    "nfl",
    "nba"
  ],
  "mode": "scoreboard",
  "dates": [],
  "teams": [],
  "includeOdds": true,
  "includeCompleted": true,
  "maxGamesPerLeague": 200,
  "maxArticles": 20,
  "maxConcurrency": 4,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Game, standing, team and article rows from ESPN's public site API, plus free league and diagnostic rows, in one schema. Delivered as JSON items in the default dataset.

# 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"
    ],
    "mode": "scoreboard",
    "dates": [],
    "teams": [],
    "includeOdds": true,
    "includeCompleted": true,
    "maxGamesPerLeague": 200,
    "maxArticles": 20,
    "maxConcurrency": 4,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/sports-scores-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "leagues": [
        "nfl",
        "nba",
    ],
    "mode": "scoreboard",
    "dates": [],
    "teams": [],
    "includeOdds": True,
    "includeCompleted": True,
    "maxGamesPerLeague": 200,
    "maxArticles": 20,
    "maxConcurrency": 4,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/sports-scores-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 '{
  "leagues": [
    "nfl",
    "nba"
  ],
  "mode": "scoreboard",
  "dates": [],
  "teams": [],
  "includeOdds": true,
  "includeCompleted": true,
  "maxGamesPerLeague": 200,
  "maxArticles": 20,
  "maxConcurrency": 4,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/sports-scores-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/sports-scores-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 <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/rKapVugFoSxlDuMhw/builds/VgdtsOUCkKKDj2NaB/openapi.json