# Tennis Results & Live Scores (Flashscore, ATP, WTA, ITF) (`fairfetch/tennis-results-live-scores`) Actor

Tennis results, live scores and schedules for ATP, WTA, Challenger and ITF: set-by-set scores with tiebreaks, round, surface, players with country and ranking, retirements and walkovers. Optional match stats. Unofficial, not affiliated with Flashscore. $0.80 per 1,000 matches.

- **URL**: https://apify.com/fairfetch/tennis-results-live-scores.md
- **Developed by:** [Naveen Raja](https://apify.com/fairfetch) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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

## Tennis Results & Live Scores (Flashscore, ATP, WTA, ITF)

Get **tennis results, live scores and order of play as clean JSON**: every ATP, WTA, Challenger, ITF, Davis Cup / Billie Jean King Cup and exhibition match of the days you pick, singles and doubles, with **set-by-set scores including tiebreak points**, the round, surface and indoor flag, both players with their country and **current ATP / WTA ranking**, status, winner, and retirement / walkover flags. Turn on statistics for **aces, double faults, first-serve %, break points saved and converted, winners, unforced errors and more** (for the match and for every set) plus set and match durations. Data comes from Flashscore's public data feed, with ESPN's public scoreboard as a fallback for ATP, WTA and WTA 125 events. No betting odds.

| What you pay for | Price |
|---|---|
| `match`: one match row (everything except statistics) | **$0.0008** ($0.80 per 1,000 matches) |
| `match-with-statistics`: one match row with its statistics and set durations (only when you turn statistics on and the match has them; replaces `match` for that row) | **$0.002** ($2 per 1,000 matches) |
| Actor start (standard Apify event, per run) | $0.00005 |

| Example | Rows | Cost |
|---|---|---|
| The prefilled input: yesterday's and today's finished singles of every tour, first 10 (ATP / WTA come first) | 10 matches | **$0.008** |
| A full day of every tour, singles and doubles (Wednesday 21 Oct 2026: 494 matches) | 494 matches | $0.40 |
| Our test run: 4 days of ATP, WTA, Challenger Men and ITF Women with statistics | 660 matches + 289 with statistics | $1.11 |
| Daily results feed: yesterday's finished ATP + WTA singles with statistics (21 Oct 2026: 24 matches) | 24 matches with statistics | $0.05 |

Apify platform costs are included: you pay only the prices above. Invalid inputs, days the sources can't serve, failed requests and the run summary are free. Set **Maximum cost per run** (or `maxTotalChargeUsd` in the API) and the Actor stops cleanly at that amount; it never fetches statistics it can't charge for.

### What you get

- **All tours on one feed**: ATP, WTA, ATP Challenger, WTA 125 (Challenger Women), ITF men and women (M15 to W100), Davis Cup and Billie Jean King Cup ties, exhibitions, plus Grand Slam mixed doubles under "Other". Pick tours, singles / doubles and statuses. Junior events are left out on purpose (their players are mostly minors).
- **Any day from 7 days back to 7 days ahead** (UTC), or a range of up to 31 days. For older days, ATP, WTA and WTA 125 events (Grand Slams included) come from ESPN, so you can also backfill last season's Wimbledon. A 31-day range across Wimbledon runs in about 6 seconds with 122 MB of memory (test run).
- **Set-by-set scores with tiebreaks**: every set's games, both players' tiebreak points, the doubles match tiebreak (to 10) flagged, sets won, and a readable `score` like `7-6(5) 2-6 6-4`.
- **Round, stage and surface**: `1/16-finals`, `Quarter-finals`, `Final`, main draw or qualification, hard / clay / grass / carpet and indoor.
- **Players**: name, country, Flashscore ID and page, and current ranking with points (ATP / WTA singles or doubles list, with the list's publication date). Doubles rows have both players of each pair.
- **Status you can trust for settling and modelling**: `scheduled`, `live`, `finished`, `interrupted`, `postponed`, `cancelled`, `abandoned`, the detailed state (`Set 3 - Tiebreak`, `Finished / retired`, `Walkover`, `Delayed`...), `resultType` (`completed`, `retired`, `walkover`, `awarded`), and withdrawal notes.
- **Live scores**: current game points (`15`, `30`, `40`, `A`) and who is serving, for matches in progress when the run reads the day.
- **Statistics (optional)**: about 20 statistics per match and per set, each with home / away values and, where the source gives them, totals and percentages (`firstServePointsWon: {home: 53, homeTotal: 70, homePercent: 76, ...}`), plus each set's and the match's duration in minutes.
- **Reliable for daily schedules**: the feed is the one Flashscore's own website reads; it answers cloud servers directly (no proxy; the prefilled input runs in about 5 seconds, two full days of every tour in about 20). If Flashscore changes its feed key, the Actor reads the new one from the website by itself; if the feed fails, ATP, WTA and WTA 125 rows come from ESPN (`source` tells you which), and other tours become free error rows instead of a failed run. A source record the Actor can't read is skipped and counted in `SUMMARY`; it never costs you the rest of the day.
- Built for automation: pay-per-event pricing, a stable schema (every row has every column), a machine-readable `SUMMARY` record per run and clear per-day errors.

### Use cases

- **Results and settlement feeds**: schedule a daily run for yesterday's finished matches and feed scores, retirements and walkovers into your database or spreadsheet.
- **Modelling and analytics**: serve / return statistics, set durations, rankings and surfaces for player-strength, fatigue or surface models. Backfill ATP, WTA and WTA 125 history from ESPN for older dates.
- **Fantasy and media**: today's order of play with rounds and rankings, live scores during the day, final results at night.
- **Lower-tier coverage**: ITF and Challenger results, which few data products cover, for scouting and player tracking.

### How to use

1. **From date / To date (UTC)**: `today`, `yesterday`, `tomorrow`, a date like `2026-10-21`, or days from today like `-3` or `+2`. From `-3` to `today` reads the last four days.
2. **Tours**: leave empty for all, or pick ATP, WTA, Challenger Men / Women, ITF Men / Women, team events, exhibitions, other.
3. **Include doubles** on or off, and **Match status** (finished, live, scheduled, interrupted, cancelled).
4. Optional **Tournament names** (`Wimbledon`, `Almaty`, `M15 Monastir`) and **Player names** (`Sinner`, `Jannik Sinner`, `Swiatek`); case and accents don't matter.
5. **Max matches** caps the rows (0 = all). Turn on **Include statistics and set durations** if you need them.
6. Run it and download JSON, CSV or Excel, or read the dataset via API. Views: **Matches**, **Live view**, **Statistics**, **Errors** and **All fields**.

#### Input examples

The prefilled input (yesterday's and today's finished singles of every tour, first 10; in season the ATP and WTA matches come first, in the off-season Challenger and ITF fill the rows):

```json
{
  "dateFrom": "yesterday",
  "dateTo": "today",
  "statuses": ["finished"],
  "includeDoubles": false,
  "maxMatches": 10
}
```

Everything played in the last three days on the ATP, WTA, Challenger and ITF Women tours, with statistics:

```json
{
  "dateFrom": "-3",
  "dateTo": "today",
  "tours": ["atp", "wta", "challenger-men", "itf-women"],
  "includeStatistics": true
}
```

Live scores of every tour right now:

```json
{ "statuses": ["live"] }
```

Tomorrow's order of play for one player, and a Grand Slam day from ESPN:

```json
{ "dateFrom": "tomorrow", "players": ["Sinner"] }
```

```json
{ "dateFrom": "2026-07-05", "tournaments": ["Wimbledon"], "dataSource": "espn" }
```

#### API examples

Run the Actor and get the rows in one call (replace `<YOUR_API_TOKEN>`):

```bash
curl -X POST "https://api.apify.com/v2/acts/fairfetch~tennis-results-live-scores/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"dateFrom": "yesterday", "tours": ["atp", "wta"], "statuses": ["finished"], "includeDoubles": false}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("fairfetch/tennis-results-live-scores").call(
    run_input={"dateFrom": "-1", "tours": ["atp"], "includeStatistics": True},
    max_total_charge_usd=1,
)
for match in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(match["date"], match["tournament"], match["round"], match["homeName"], match["awayName"], match["score"])
```

### Output

One row per match. A real row from our test run on 22 Oct 2026 (statistics shortened: the full row has about 20 statistics for the match and the same for every set):

```json
{
  "matchId": "ITD2mo8U",
  "source": "flashscore",
  "matchUrl": "https://www.flashscore.com/match/ITD2mo8U/",
  "date": "2026-10-19",
  "startTimeUtc": "2026-10-19T04:05:00Z",
  "tour": "WTA",
  "category": "WTA - Singles",
  "matchType": "singles",
  "gender": "women",
  "tournament": "Ningbo",
  "tournamentCountry": "China",
  "tournamentCity": null,
  "tournamentStage": "main",
  "round": "1/16-finals",
  "surface": "hard",
  "indoor": false,
  "tournamentId": "fmWMWgpp",
  "tournamentUrl": "https://www.flashscore.com/tennis/wta-singles/ningbo/",
  "status": "finished",
  "statusDetail": "Finished",
  "resultType": "completed",
  "isRetirement": false,
  "isWalkover": false,
  "homeName": "Mertens E.",
  "awayName": "Fernandez L.",
  "homeCountry": "Belgium",
  "awayCountry": "Canada",
  "homeRanking": 15,
  "awayRanking": 30,
  "homePlayers": [
    { "name": "Mertens E.", "country": "Belgium", "id": "Y1ZrrUtl",
      "url": "https://www.flashscore.com/player/mertens-elise/Y1ZrrUtl/", "ranking": 15, "rankingPoints": 2540 }
  ],
  "awayPlayers": [
    { "name": "Fernandez L.", "country": "Canada", "id": "8EI3pJOd",
      "url": "https://www.flashscore.com/player/fernandez-leylah-annie/8EI3pJOd/", "ranking": 30, "rankingPoints": 1709 }
  ],
  "setsHome": 1,
  "setsAway": 2,
  "score": "6-2 3-6 5-7",
  "sets": [
    { "set": 1, "home": 6, "away": 2, "tiebreakHome": null, "tiebreakAway": null, "matchTiebreak": false, "durationMinutes": 43 },
    { "set": 2, "home": 3, "away": 6, "tiebreakHome": null, "tiebreakAway": null, "matchTiebreak": false, "durationMinutes": 57 },
    { "set": 3, "home": 5, "away": 7, "tiebreakHome": null, "tiebreakAway": null, "matchTiebreak": false, "durationMinutes": 70 }
  ],
  "winner": "away",
  "winnerName": "Fernandez L.",
  "currentGameHome": null,
  "currentGameAway": null,
  "serving": null,
  "durationMinutes": 170,
  "statistics": {
    "match": {
      "aces": { "home": 0, "away": 1 },
      "doubleFaults": { "home": 7, "away": 11 },
      "firstServePercentage": { "home": 64, "away": 66, "homePercent": 64, "awayPercent": 66 },
      "firstServePointsWon": { "home": 32, "away": 40, "homeTotal": 56, "awayTotal": 68, "homePercent": 57, "awayPercent": 59 },
      "breakPointsConverted": { "home": 7, "away": 7, "homeTotal": 14, "awayTotal": 12 }
    },
    "set1": { "...": "the same statistics for set 1" }
  },
  "note": null,
  "rankingList": "WTA singles",
  "rankingDate": "2026-10-18",
  "scrapedAt": "2026-10-22T03:02:37Z",
  "input": null,
  "error": null,
  "errorKind": null
}
```

A live row adds the game score and server, e.g. `"status": "live", "statusDetail": "Set 1", "score": "2-1", "currentGameHome": "0", "currentGameAway": "0", "serving": "away"`.

Statistics keys (match and each set; Flashscore publishes them for ATP, WTA and most Challenger matches, rarely for ITF): `aces`, `doubleFaults`, `firstServePercentage`, `firstServePointsWon`, `secondServePointsWon`, `breakPointsSaved`, `firstReturnPointsWon`, `secondReturnPointsWon`, `breakPointsConverted`, `winners`, `unforcedErrors`, `netPointsWon`, `servicePointsWon`, `returnPointsWon`, `totalPointsWon`, `lastTenBalls`, `matchPointsSaved`, `serviceGamesWon`, `returnGamesWon`, `totalGamesWon` (the exact list is what the source shows for the match).

**Error rows** are free and have `error`, `errorKind` and `input` (the day or input they are about), with every other column empty: `invalid_input` (the input can't be used), `not_covered` (a day or tour the sources don't cover), `source_error` / `blocked` (the source failed for that day). The `SUMMARY` record in the run's key-value store has per-day counts, the source used for each day, rankings used and request totals.

### FAQ

**Which days can I get?** Flashscore lists today and the 7 days before and after it. For other dates, ATP, WTA and WTA 125 events (Grand Slams included) come from ESPN (Automatic or ESPN source); ATP Challenger, ITF and team events aren't available for those days and you get a free `not_covered` row per day.

**Is a day exactly a UTC day?** Almost. A day is Flashscore's list for that day: matches starting after 23:00 UTC are listed on the next day, and a few 00:00 UTC placeholders on the previous one. `date` is always the match's real UTC start date, so filter on it if you need strict UTC days. When today is in the range and live matches are wanted, the live matches that started after 23:00 UTC (on tomorrow's list) are added, so "live right now" doesn't miss them. A match listed on two days is returned once.

**Are the rankings from the match day?** No: they are the current ATP / WTA rankings (singles or doubles, matching the match type) from Flashscore's ranking lists, with the list's date in `rankingDate`. Unranked players and team ties have `null`. Seeds aren't in the feed.

**Why is `round` empty for some matches?** The round comes from each tournament's results and fixtures lists, which don't include matches that are live, interrupted or cancelled at that moment; in our 949-match test run 95% of rows had a round. Run again after the match to get it.

**How live are live scores?** They are a snapshot taken when the run reads the day (a few seconds). Schedule the Actor every few minutes during play if you need updates.

**Who is "home"?** The player (or pair) listed first by the source; for tennis it carries no meaning beyond order. `winner` says `home` or `away`.

**What does ESPN fallback change?** ESPN rows have `source: "espn"`, ESPN's full player names (`Jannik Sinner` instead of `Sinner J.`), ESPN's sponsor names for tournaments ("BNP Paribas Fortis European Open" for Brussels: the city is in `tournamentCity`, and the tournament filter matches it), ESPN round names (`Round 2`), and no surface, rankings, statistics or match link. Country names are mapped to Flashscore's ("Great Britain" becomes "United Kingdom"). ESPN has no tier field, so WTA 125 events are recognised from a list of ESPN tournament IDs kept with the Actor (2026 calendar) and labelled Challenger Women like on Flashscore. Backfills of earlier seasons use the same 2026 list, so an event that changed tier since then is labelled by its 2026 tier, and a new WTA 125 event that isn't on the list yet shows as WTA. Use **Data source: Flashscore only** if you never want ESPN rows.

**Do I need a proxy?** No, and there is no proxy setting. Both sources answer cloud servers directly. If a source ever blocks a direct request, the Actor moves to Apify Proxy (datacenter) on its own at no extra cost to you.

**Can I get betting odds?** No. The Actor never collects bookmaker odds or betting data.

### Limits

- Day window: today ±7 days on Flashscore; ESPN covers ATP, WTA and WTA 125 events (Grand Slams included) on any date, but no ATP Challenger, ITF or team events. At most 31 days per run.
- A day is Flashscore's list for that day, close to the UTC day (see FAQ); `date` is the real UTC start.
- Junior events are not included.
- Rankings are current, not as of the match date; no seeds.
- Round is missing for matches that are live, interrupted or cancelled at the time of the run.
- Statistics exist only where Flashscore publishes them (most ITF matches have none: they stay plain `match` rows and cost $0.0008).
- The sources are unofficial and can change without notice. The Actor detects a changed feed key and refreshes it; a changed feed format fails that day with a clear error row instead of returning wrong data.

### Legal note

This Actor reads public sports results (facts such as scores, dates and rankings) of players in professional and ITF World Tennis Tour events, the same data the Flashscore and ESPN websites show to every visitor. It collects nothing about players beyond the names, countries, rankings and source IDs / profile links published with those results, leaves out junior events (their players are mostly minors), and collects no betting odds. Flashscore's terms of use and ESPN's terms of use restrict automated access; you are responsible for using the data in line with the terms that apply to you and the laws of your country.

robots.txt, checked on 22 Oct 2026: the feed host the Actor reads (`global.flashscore.ninja`) has no robots.txt (HTTP 404). On `www.flashscore.com` the rules for all crawlers disallow the website's live / finished / scheduled pages, draw and standings pages and the day pages for 2-7 days back or ahead (for example `*/day-3/`); the Actor doesn't load those pages: it reads the same days from the feed host. It loads the home page and a tournament's results page (both allowed) only to refresh the feed key or the season ID when needed. ESPN's API host (`site.api.espn.com`) answers its robots.txt with "Access Denied", so no rules could be read there; `www.espn.com/robots.txt` doesn't cover the API host.

**Not affiliated** with, endorsed by or connected to Flashscore, Livesport s.r.o., ESPN, the ATP, the WTA or the ITF. All trademarks belong to their owners and are used only to describe the data.

# Actor input Schema

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

First day to read: a date like 2026-10-21, "today", "yesterday", "tomorrow", or a number of days from today like -3 or +2 (UTC). Flashscore lists today and the 7 days before and after it; a day is Flashscore's list for that day, which is close to the UTC day (matches starting after 23:00 UTC are listed on the next day). For other dates, ATP, WTA and WTA 125 events (Grand Slams included) come from ESPN when "Data source" is Automatic or ESPN; ATP Challenger, ITF and team events aren't available for those days.

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

Last day to read, in the same formats. Leave empty to read only the "From date". At most 31 days per run. Example: From "-3" To "today" = the last four days.

## `tours` (type: `array`):

Which tours to return. Leave empty for all of them. Challenger Women are the WTA 125 events; "Team events" are the Davis Cup and Billie Jean King Cup ties; "Other" covers Grand Slam mixed doubles and any other category Flashscore lists. Junior events are never returned (their players are mostly minors).

## `includeDoubles` (type: `boolean`):

Also return doubles matches (both players of each pair, with their doubles ranking). Turn off for singles only.

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

Which matches to return. Leave empty for all. "Finished" includes retirements, walkovers and awarded matches (see resultType). "Cancelled" also covers postponed and abandoned matches. Live scores are a snapshot taken when the run reads the day; when today is requested, live matches that started after 23:00 UTC (listed on tomorrow's feed) are included too.

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

Only matches of tournaments whose name contains one of these words, e.g. "Wimbledon", "Almaty" or "M15 Monastir". On ESPN rows the venue city also counts (ESPN uses sponsor names like "BNP Paribas Fortis European Open" for Brussels). Case and accents don't matter; every word must match the start of a word in the name.

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

Only matches with one of these players, e.g. "Sinner", "Jannik Sinner" or "Swiatek". Case and accents don't matter; every word must match the start of a word in the player's name.

## `maxMatches` (type: `integer`):

Stop after this many match rows (in the order the source lists them: by day, then tournament). 0 = no limit.

## `includeStatistics` (type: `boolean`):

Add Flashscore's match statistics (aces, double faults, first-serve %, points won on serve and return, break points saved and converted, winners, unforced errors and more; for the match and each set) and the duration of every set and of the match. Needs two extra requests per played match, so runs take longer. A row with statistics is charged as "Match with statistics" instead of "Match"; matches without published statistics (most ITF matches) stay plain match rows.

## `dataSource` (type: `string`):

Automatic: Flashscore for today ±7 days; ESPN's public scoreboard for ATP, WTA and WTA 125 events (Grand Slams included) when Flashscore fails or for older dates. Flashscore only: never use ESPN. ESPN only: ATP, WTA and WTA 125 events for any date, without surfaces, rankings or statistics (other tours get a free "not covered" row per day). The "source" column says where each row came from.

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

How many requests run at the same time (mainly matters with statistics on).

## `requestTimeoutSecs` (type: `integer`):

Timeout for a single HTTP request.

## `maxRetries` (type: `integer`):

Retries for network errors, HTTP 5xx and rate limits, with exponential backoff.

## Actor input object example

```json
{
  "dateFrom": "yesterday",
  "dateTo": "today",
  "tours": [],
  "includeDoubles": true,
  "statuses": [
    "finished"
  ],
  "tournaments": [
    "Almaty",
    "Brussels"
  ],
  "players": [
    "Sinner",
    "Swiatek"
  ],
  "maxMatches": 10,
  "includeStatistics": false,
  "dataSource": "auto",
  "maxConcurrency": 8,
  "requestTimeoutSecs": 30,
  "maxRetries": 3
}
```

# Actor output Schema

## `matches` (type: `string`):

All rows from this run as JSON.

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

Date, tournament, round, status, players, score, winner and rankings.

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

Per-day counts, sources used, errors and request totals.

# 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 = {
    "dateFrom": "yesterday",
    "dateTo": "today",
    "tours": [],
    "includeDoubles": false,
    "statuses": [
        "finished"
    ],
    "maxMatches": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fairfetch/tennis-results-live-scores").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 = {
    "dateFrom": "yesterday",
    "dateTo": "today",
    "tours": [],
    "includeDoubles": False,
    "statuses": ["finished"],
    "maxMatches": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fairfetch/tennis-results-live-scores").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 '{
  "dateFrom": "yesterday",
  "dateTo": "today",
  "tours": [],
  "includeDoubles": false,
  "statuses": [
    "finished"
  ],
  "maxMatches": 10
}' |
apify call fairfetch/tennis-results-live-scores --silent --output-dataset

```

## MCP server setup

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

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/yXZs7Z6jR30gdciwR/builds/wYhVwc02fb548X4n9/openapi.json