# Sports Results & Live Scores: Tennis, Football, NFL, NBA (`onibaku/sports-results`) Actor

Tennis, football and US sports fixtures, live scores and results with set-by-set and period scores, plus league tables and ATP/WTA rankings. Premier League, Champions League, NFL, NBA, MLB, NHL, F1 and cricket. Filter by date, team, player and status. No API key.

- **URL**: https://apify.com/onibaku/sports-results.md
- **Developed by:** [Onibaku](https://apify.com/onibaku) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 matches

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

## Sports Results, Live Scores & Standings (Tennis, Football, NFL, NBA, F1, Cricket)

Get **fixtures, live scores and final results** for tennis, football (soccer) and the big US leagues as one clean,
flat dataset: one row per match with the **set-by-set or period-by-period score**, status, round, venue, winner and a
link to the match page. Switch to standings mode for **league tables and the ATP/WTA rankings**.

- **Tennis:** every ATP and WTA match ESPN covers (Slams, tour events and some Challengers), singles and doubles,
  qualifying included. Tournament, round, draw,
  players, seeds, countries, set scores with tiebreaks, retirements and walkovers, court. Plus the ATP and WTA
  singles rankings (top 150, points and movement).
- **Football:** Premier League, Championship, FA Cup, Carabao Cup, WSL, Scottish Premiership, LaLiga, Bundesliga,
  Serie A, Ligue 1, Eredivisie, Primeira Liga, Champions League, Europa League, Conference League, MLS, Liga MX,
  Brazil, Argentina, World Cup, and any other league ESPN covers. Scorers, cards and minutes. League tables with
  played, won, drawn, lost, goal difference, points and the Champions League/relegation notes.
- **US sports:** NFL, NCAA football, NBA, WNBA, NCAA basketball, MLB, NHL. Quarter/period/inning scores, team records,
  playoff series notes, betting lines where ESPN shows them, and an optional **team box score** (yards, possession,
  shots, rebounds...). Standings with win %, games behind and streak.
- **F1, IndyCar, NASCAR:** every session of a race weekend (practice, qualifying, race) with the finishing order, plus
  driver and constructor standings.
- **Cricket:** every series ESPN is covering right now (Tests, ODIs, T20s, IPL, domestic cricket) with innings
  scores (runs, wickets, overs) and the result line. Points tables where the competition has one.

No API key, no login, no proxy. Runs take seconds and cost almost nothing in compute.

### What it's for

- **Betting models and tipsters:** pull yesterday's results and today's fixtures every morning, with set and period
  scores, to settle bets and feed your models. Run it every few minutes for live scores.
- **Fantasy sports:** standings, form (`WLDWW`), records and box scores for your league tools and newsletters.
- **Sports apps, bots and widgets:** a Discord/Slack/Telegram bot that posts Premier League scores, a club website
  fixture list, a live tennis ticker. One API call, one row shape for every sport.
- **Data journalism and research:** a season of results in a spreadsheet in a few runs; rankings and tables
  snapshotted on a schedule.
- **AI agents:** "Who won in Basel today?" or "Show me the Premier League table" as a single tool call (see MCP below).

### Input

| Field | What it does |
| --- | --- |
| `mode` | `matches` (fixtures, live and results, the default) or `standings` (league tables; ATP/WTA rankings for tennis). |
| `leagues` | Pick from the list: tennis/atp, tennis/wta, soccer/eng.1, football/nfl, basketball/nba, racing/f1, cricket/all and more. |
| `customLeagues` | Any other ESPN league as `sport/league`, e.g. `soccer/ger.2`, `soccer/jpn.1`, `cricket/8048` (IPL). |
| `dateFrom`, `dateTo` | `YYYY-MM-DD`, `today`, `yesterday`, `tomorrow`, or an offset such as `-7` or `+3`. Defaults to today. Up to 31 days per run. |
| `timezone` | Which time zone the dates mean (e.g. `Europe/London`). A match belongs to the day it starts there. Default UTC. |
| `statuses` | Any of `upcoming`, `live`, `finished`, `postponed`, `cancelled`. Empty means all. |
| `teamsOrPlayers` | Only matches involving any of these: `Arsenal`, `Sinner`, `Swiatek`, `Lakers`. Accents and case don't matter. |
| `tournaments` | Only matches whose tournament, league or round contains any of these: `Wimbledon`, `Basel`, `Final`. |
| `tennisDraws` | Men's/women's singles, men's/women's/mixed doubles. Empty means all. |
| `includeTeamStats` | Adds the team box score to football and US sports games (one extra request per game). |
| `season` | Standings only: the season year, e.g. `2025` for 2025-26. Empty means the current season. |
| `maxResults` | Stop after this many rows (default 1,000). |

**Today's ATP and WTA singles:**

```json
{
    "leagues": ["tennis/atp", "tennis/wta"],
    "tennisDraws": ["mens-singles", "womens-singles"]
}
```

**Last weekend's Premier League and Championship results, UK time:**

```json
{
    "leagues": ["soccer/eng.1", "soccer/eng.2"],
    "dateFrom": "-3",
    "dateTo": "yesterday",
    "timezone": "Europe/London",
    "statuses": ["finished"]
}
```

**Live NBA and NHL scores (schedule it every few minutes):**

```json
{
    "leagues": ["basketball/nba", "hockey/nhl"],
    "statuses": ["live"]
}
```

**Every match Arsenal or Sinner plays in the next two weeks:**

```json
{
    "leagues": ["soccer/eng.1", "soccer/uefa.champions", "tennis/atp"],
    "dateTo": "+14",
    "teamsOrPlayers": ["Arsenal", "Sinner"]
}
```

**League tables and rankings:**

```json
{
    "mode": "standings",
    "leagues": ["soccer/eng.1", "soccer/esp.1", "basketball/nba", "racing/f1", "tennis/atp", "tennis/wta"]
}
```

### Output

One row per match. The same shape for every sport; fields a sport doesn't have are `null` or empty.

```json
{
    "matchId": "185161",
    "eventId": "23-2026",
    "sport": "tennis",
    "league": "tennis/atp",
    "leagueName": "ATP",
    "tournament": "Swiss Indoors Basel",
    "season": "2026",
    "round": "Round 1",
    "draw": "Men's Doubles",
    "startTime": "2026-10-26T11:10:00.000Z",
    "status": "finished",
    "statusDetail": "Final",
    "home": "Jakub Paul / Matej Vocel",
    "away": "Alex Michelsen / Botic Van De Zandschulp",
    "homeScore": 0,
    "awayScore": 2,
    "score": "5-7 1-6",
    "winner": "Alex Michelsen / Botic Van De Zandschulp",
    "resultNote": "Alex Michelsen (USA) & Botic Van De Zandschulp (NED) bt Jakub Paul (SUI) & Matej Vocel (CZE) 7-5 6-1",
    "periodScores": [
        { "period": 1, "home": 5, "away": 7, "homeTiebreak": null, "awayTiebreak": null },
        { "period": 2, "home": 1, "away": 6, "homeTiebreak": null, "awayTiebreak": null }
    ],
    "competitors": [
        { "name": "Jakub Paul / Matej Vocel", "type": "pair", "players": ["Jakub Paul", "Matej Vocel"], "seed": null, "score": 0, "winner": false, "periods": [...] },
        { "name": "Alex Michelsen / Botic Van De Zandschulp", "type": "pair", "players": [...], "score": 2, "winner": true, "periods": [...] }
    ],
    "keyEvents": [],
    "odds": null,
    "venue": "Basel, Switzerland",
    "court": "IWB Court 1",
    "url": "https://www.espn.com/tennis/scoreboard/tournament/_/eventId/23-2026/competitionType/1",
    "scrapedAt": "2026-10-26T22:35:38.345Z"
}
```

How to read it:

- `status` is `upcoming`, `live`, `finished`, `postponed` or `cancelled`; `statusDetail` is ESPN's own wording
  ("FT", "Retired", "Walkover", "Q3 4:12", "Stumps").
- **Tennis:** `homeScore`/`awayScore` are sets won; `score` reads like `7-6(5) 3-6 6-4` from the first-listed
  player's side, with the tiebreak loser's points in brackets. `home` and `away` are just ESPN's listing order.
  `seed` is the player's seed in that tournament.
- **Football and US sports:** `homeScore`/`awayScore` are goals or points; `periodScores` are halves, quarters,
  periods or innings where ESPN gives them. Football's `keyEvents` lists goals and cards with the minute and player.
  `odds` (provider, spread, over/under, moneylines) appears on games where ESPN shows a line.
- **Racing:** one row per session (`round` is `FP1`, `Qual`, `Race`...); `competitors` is the classification in order.
- **Cricket:** scores are text (`259/6 (86 ov)`), each competitor's `periods` are innings with runs, wickets and
  overs, and `resultNote` is the result or match situation ("Lumbini won by 7 wkts").
- With `includeTeamStats`, `teamStats.home` and `teamStats.away` hold the box score, keyed by ESPN's stat names.

In standings mode, one row per table position: `leagueName`, `season`, `group` (conference, division or group),
`rank`, `name`, `played`, `wins`, `draws`, `losses`, `points`, `goalDifference`, `winPercent`, `gamesBehind`,
`streak`, `note` (e.g. "Champions League") and `stats` with every column ESPN shows. Tennis rows are the ATP or WTA
singles rankings with `rank`, `previousRank`, `points`, `country` and `age`.

### Pricing

**$0.002 per match returned** and **$0.001 per standings or rankings row**, plus a token $0.00005 per run.
1,000 matches cost $2. A full Premier League table is 20 rows, $0.02; the ATP top 150 is $0.15. Days with no games
cost nothing beyond the start fee.

### Good to know

- Results are as fresh as ESPN's scoreboard, usually within a minute or so of the real score.
- Leagues are ESPN's codes. The list covers the popular ones; the code for anything else is the part after
  `/sports/` in ESPN's API addresses (e.g. `soccer/ger.2`, `rugby/164205`). `cricket/all` picks up every series ESPN
  is showing now; for a specific competition use its series number, e.g. `cricket/8048` for the IPL.
- Off-season leagues and rest days simply return no rows; the run still succeeds.
- Tennis covers what ESPN carries: the Slams and ATP and WTA tour events with their qualifying, plus some Challenger
  and WTA 125 events. ITF events aren't on ESPN, so they aren't here either.
- Point-by-point tennis data and live odds movement aren't available from this source.
- **This uses ESPN's public but unofficial site API.** It isn't documented and can change without notice. The actor
  reads every field defensively (anything missing comes out as `null`) and is fixed quickly when something moves.
  It sends a few requests at a time and backs off when ESPN asks it to.

### Use it from Claude, ChatGPT or Cursor (MCP)

AI assistants can call this actor as a tool through Apify's MCP server. Add this server URL to your MCP client and
sign in with your Apify account when prompted:

```
https://mcp.apify.com?tools=onibaku/sports-results
```

Then ask things like "What were yesterday's Premier League results?", "Is Sinner playing today?" or "Show me the NBA
standings".

### Data source

ESPN's public scoreboard, standings and rankings JSON (site.api.espn.com), the same data that powers ESPN's own
scoreboards. Match rows link to their page on ESPN where it has one. This actor is independent and **isn't affiliated with,
endorsed by or sponsored by ESPN**; team, league and tournament names belong to their owners.

Questions or feature requests? Open an issue on the actor's Issues tab or email admin@onibaku.co.uk.

# Actor input Schema

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

Matches: fixtures, live scores and results for the dates below (one row per match). Standings: the current league table, or the ATP/WTA singles rankings for tennis (one row per position, dates are ignored).

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

Which sports and leagues to cover. Cricket covers every series ESPN is showing now (international tours, IPL, county and domestic cricket). Need another league? Add its ESPN code under Other leagues.

## `customLeagues` (type: `array`):

Any other ESPN league as sport/league, e.g. soccer/ger.2 (2. Bundesliga), soccer/tur.1, soccer/jpn.1, rugby/164205 (Rugby World Cup), cricket/8048 (IPL), golf/pga. The code is the part after /sports/ in ESPN API URLs.

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

First day of matches: YYYY-MM-DD, today, yesterday, tomorrow, or a day offset such as -3 or +7. Defaults to today.

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

Last day of matches, in the same forms. Leave empty for just the From date. At most 31 days per run.

## `timezone` (type: `string`):

Which time zone the dates mean, as an IANA name such as Europe/London or America/New_York. A match belongs to the day it starts in this zone. Start times in the output are always UTC.

## `statuses` (type: `array`):

Which matches to return. Leave empty for all of them.

## `teamsOrPlayers` (type: `array`):

Only matches involving one of these, matched against team and player names, case- and accent-insensitive, e.g. Arsenal, Sinner, Swiatek, Lakers. Short codes such as LAL or ARS match team abbreviations.

## `tournaments` (type: `array`):

Only matches whose tournament, league or round contains one of these, e.g. Wimbledon, Paris, Basel, Final.

## `tennisDraws` (type: `array`):

Which tennis draws to return. Leave empty for all (singles and doubles, qualifying included).

## `includeTeamStats` (type: `boolean`):

For football, NFL, NBA, MLB and NHL games that have started, add the team box score (possession, shots, corners, yards, rebounds and so on). One extra request per match, so runs are slower.

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

Year of the season for league tables, e.g. 2025 for the 2025-26 Premier League. Leave empty for the current season. Tennis rankings are always the latest.

## `maxResults` (type: `integer`):

Stop after this many rows.

## Actor input object example

```json
{
  "mode": "matches",
  "leagues": [
    "tennis/atp",
    "tennis/wta",
    "soccer/eng.1",
    "basketball/nba"
  ],
  "dateFrom": "today",
  "timezone": "UTC",
  "includeTeamStats": false,
  "maxResults": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `standings` (type: `string`):

No description

## `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 = {
    "leagues": [
        "tennis/atp",
        "tennis/wta",
        "soccer/eng.1",
        "basketball/nba"
    ],
    "dateFrom": "today",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("onibaku/sports-results").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": [
        "tennis/atp",
        "tennis/wta",
        "soccer/eng.1",
        "basketball/nba",
    ],
    "dateFrom": "today",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("onibaku/sports-results").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": [
    "tennis/atp",
    "tennis/wta",
    "soccer/eng.1",
    "basketball/nba"
  ],
  "dateFrom": "today",
  "maxResults": 20
}' |
apify call onibaku/sports-results --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,onibaku/sports-results"
        }
    }
}
```

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/v1JhLze0guMfhZrMq/builds/G7liczIghpgBpkjYz/openapi.json