# Flashscore Tennis Scraper - Live Scores, Results & H2H (`confidential_gnat/flashscore-tennis-scraper`) Actor

Flashscore tennis scraper for live scores, fixtures and results: ATP, WTA, Challenger and ITF, singles and doubles. Sets, tiebreaks, rankings, players, tournaments and surface, plus optional match stats, head-to-head (H2H) and point-by-point. Export to JSON, CSV or Excel or use the API.

- **URL**: https://apify.com/confidential_gnat/flashscore-tennis-scraper.md
- **Developed by:** [ActorFlow](https://apify.com/confidential_gnat) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Flashscore Tennis Scraper - Live Scores, Results & H2H

**Scrape tennis matches from Flashscore (flashscore.com)**: fixtures, live scores and results for ATP, WTA, Challenger and ITF, singles and doubles. Each match comes out with its sets and tiebreaks, players and rankings, tournament and surface, plus optional **match stats** and **head-to-head**, ready to export as **JSON, CSV or Excel** or to call as an **API**. Pick the days and press Start.

**Target website:** [flashscore.com](https://www.flashscore.com/tennis/)

![Flashscore Tennis Scraper cover](https://i.postimg.cc/1tyYF7Hk/Gemini-Generated-Image-b2gntmb2gntmb2gn.jpg)

### ✨ Features of this Flashscore tennis scraper

- **Tennis match extraction** — fixtures, live matches and finished results with the score of every set, tiebreak points, winner, start and end time.
- **Players and rankings** — both sides with name, country, current ranking, photo and Flashscore profile id, for singles and doubles.
- **Tournament data** — tournament name, country, category (ATP, WTA, Challenger, ITF) and surface (hard, clay, grass, carpet).
- **Live score details** — for live matches the current set, the server and the points of the current game.
- **Match stats on demand** — set durations, match duration, referee and the full statistics (aces, double faults, serve and return points, break points, winners, errors).
- **Head-to-head on demand** — the previous meetings of the two players and the last matches of each.
- **Point-by-point on demand** — every game of every set with the server, the winner, whether the serve was broken, the points of the game with break, set and match points flagged, and the tiebreak points in order.
- **Filters** — by tour, match status, singles or doubles, tournament name, or a tournament page URL.
- **Proxy support** — optional; runs work without one.
- **No browser required** — plain requests keep runs fast and cheap.

### 🚀 How to scrape Flashscore tennis matches in 5 steps

1. [Sign up](https://apify.com/sign-up) for a free Apify account — includes **$5 monthly credit**.
2. Open the actor page and click **Try for free**.
3. Fill in the **Input** fields (the default tennis page works as is; choose the days and filters you want).
4. Click **Start** and wait for the run to complete.
5. Download results from the **Output** tab in JSON, CSV, or Excel format.

You can also run this actor via the [Apify API](https://docs.apify.com/api/v2) or integrate it directly into your workflows using [Zapier](https://zapier.com/apps/apify), [Make](https://www.make.com/), or [n8n](https://n8n.io/).

### 💰 Pricing for the Flashscore tennis scraper

This actor uses **pay-per-result** billing based on the compute units a run consumes.

- New Apify accounts include **$5 of free monthly credit**.
- The actor uses plain HTTP requests instead of a browser, so it costs significantly less to run than browser-based scrapers.
- The proxy is off by default, which keeps runs cheapest.

### 🖼️ Flashscore tennis scraper input screenshot

![Flashscore Tennis Scraper input form in Apify Console: tennis URLs, max matches per URL, days back, days ahead, tours, match status, scrape match details and include head-to-head](https://i.postimg.cc/FKyB7Xjn/Gemini-Generated-Image-wb8gp2wb8gp2wb8g.jpg)

The numbers match the input fields below:

1. **Flashscore tennis URLs**: the tennis page, a tournament page or a match page.
2. **Max matches per URL**: the match limit for each start URL.
3. **Days back**: also scrape matches from this many days before today.
4. **Days ahead**: also scrape fixtures from this many days after today.
5. **Tours**: ATP, WTA, Challenger, ITF or Other.
6. **Match status**: scheduled, live or finished matches.
7. **Scrape match details**: add match stats and more detail to each row.
8. **Include head-to-head**: add the players' previous meetings.

### 🔧 Flashscore tennis scraper input configuration

The input form starts with the Flashscore URLs and the match limit, then the days and filters, and the two detail switches. The proxy settings are last.

| Field | Type | Required | Default | Description |
| ----- | ---- | -------- | ------- | ----------- |
| Flashscore tennis URLs (`startUrls`) | array | — | the Flashscore tennis page | The tennis page for all matches, a tour or tournament page to keep only its matches, or a match page with `?mid=` for one match. |
| Max matches per URL (`maxItems`) | integer | — | 5 | Maximum matches saved for each start URL. |
| Days back (`daysBack`) | integer | — | 0 | Also scrape the matches of this many days before today (0 to 7). |
| Days ahead (`daysAhead`) | integer | — | 0 | Also scrape the fixtures of this many days after today (0 to 7). |
| Tours (`tours`) | array | — | all | `atp`, `wta`, `challenger`, `itf` or `other`. |
| Match status (`matchStatuses`) | array | — | all | `scheduled`, `live` or `finished` (finished includes retired and walkover). |
| Singles or doubles (`matchType`) | string | — | `all` | `all`, `singles` or `doubles`. |
| Tournament names (`tournaments`) | array | — | — | Keep only tournaments whose name contains one of these words, for example Paris or Roland Garros. |
| Scrape match details (`scrapeDetails`) | boolean | — | false | Adds set and match durations, the referee and the match statistics for matches that have started. |
| Include head-to-head (`includeHeadToHead`) | boolean | — | false | Adds the previous meetings of the two players and the last matches of each. |
| Include point-by-point (`includePointByPoint`) | boolean | — | false | Adds every game of every set with server, winner, break flag, the points of the game (0:15, 30:40...) and the tiebreak points, for matches that have started. |
| Proxy configuration (`proxyConfiguration`) | object | — | no proxy | Turn on Apify Proxy if your runs get blocked. |

**Supported URL types:**

- All tennis: `https://www.flashscore.com/tennis/`
- A tour: `https://www.flashscore.com/tennis/atp-singles/`
- A tournament: `https://www.flashscore.com/tennis/atp-singles/paris/`
- One match: `https://www.flashscore.com/match/tennis/<player>/<player>/?mid=<match id>`

### 📦 Flashscore tennis scraper output data

Every match is one flat record in the dataset with the keys `matchId`, `url`, `startTime`, `endTime`, `status`, `matchType`, `tour`, `winner`, `note`, `setsHome`, `setsAway`, `sets`, `homeName`, `homeId`, `homeSlug`, `homeCountry`, `homeRanking`, `homePhoto`, `awayName`, `awayId`, `awaySlug`, `awayCountry`, `awayRanking`, `awayPhoto`, `tournamentId`, `tournamentName`, `tournamentUrl`, `tournamentCountry`, `category`, `surface`, `liveSet`, `currentServer`, `currentGameHome`, `currentGameAway`, `totalDurationMinutes`, `referee`, `stats`, `headToHead`, `pointByPoint`, `source` and `scrapedAt`. Every record has all keys; a value the source does not carry is `null`. The dataset has 1 view:

- **Matches** — a compact table of start time, status, tour, tournament, both players, sets won, winner, surface and the match link.

**Output at a glance:**

| Start (UTC) | Status | Tournament | Match | Sets | Score |
| ----------- | ------ | ---------- | ----- | ---- | ----- |
| 2026-10-28 20:20 | finished | Basel (hard) | [Hurkacz H. v Rune H.](https://www.flashscore.com/match/tennis/hurkacz-hubert-jPfeGTme/rune-holger-rXC2E7I7/?mid=lljX5Uwp) | 1-2 | 6-3 3-6 6-7 |
| 2026-10-29 11:10 | finished | Basel (hard) | [Vacherot V. v Jodar R.](https://www.flashscore.com/match/tennis/vacherot-valentin-hvO1oqO8/jodar-rafael-04R9qNhL/?mid=zui4APmJ) | 2-1 | 7-6 2-6 7-6 |
| 2026-10-29 14:00 | finished | Basel (hard) | [Michelsen A. v Fils A.](https://www.flashscore.com/match/tennis/michelsen-alex-80ckEuup/arthur-fils-GQ0cCJ9d/?mid=Sdd0CkDT) | 1-2 | 6-4 3-6 6-7 |
| 2026-10-29 16:15 | live | Basel (hard) | [Altmaier D. v Lehecka J.](https://www.flashscore.com/match/tennis/altmaier-daniel-hrSKAZV7/lehecka-jiri-KlK6YxOE/?mid=Cj3niUYb) | 0-1 | 5-7 1-0 |
| 2026-10-29 18:05 | scheduled | Basel (hard) | [Djokovic N. v Struff J-L.](https://www.flashscore.com/match/tennis/djokovic-novak-QyWKKemm/struff-jan-lennard-bkUSIZHa/?mid=MqJeOPTI) | — | — |

**Sample output (raw JSON):**

```json
[
  {
    "matchId": "lljX5Uwp",
    "url": "https://www.flashscore.com/match/tennis/hurkacz-hubert-jPfeGTme/rune-holger-rXC2E7I7/?mid=lljX5Uwp",
    "startTime": "2026-10-28T20:20:00.000Z",
    "endTime": "2026-10-28T22:16:52.000Z",
    "status": "finished",
    "matchType": "singles",
    "tour": "atp",
    "winner": "away",
    "note": null,
    "setsHome": 1,
    "setsAway": 2,
    "sets": [
      {
        "set": 1,
        "homeGames": 6,
        "awayGames": 3,
        "homeTiebreak": null,
        "awayTiebreak": null,
        "durationMinutes": 34
      },
      {
        "set": 2,
        "homeGames": 3,
        "awayGames": 6,
        "homeTiebreak": null,
        "awayTiebreak": null,
        "durationMinutes": 29
      },
      {
        "set": 3,
        "homeGames": 6,
        "awayGames": 7,
        "homeTiebreak": 7,
        "awayTiebreak": 9,
        "durationMinutes": 57
      }
    ],
    "homeName": "Hurkacz H.",
    "homeId": "jPfeGTme",
    "homeSlug": "hurkacz-hubert",
    "homeCountry": "Poland",
    "homeRanking": 154,
    "homePhoto": "https://static.flashscore.com/res/image/data/fg7OyO7k-xEfD5uDB.png",
    "awayName": "Rune H.",
    "awayId": "rXC2E7I7",
    "awaySlug": "rune-holger",
    "awayCountry": "Denmark",
    "awayRanking": 63,
    "awayPhoto": "https://static.flashscore.com/res/image/data/MamwNzme-tSf4B4RM.png",
    "tournamentId": "t8icmqob",
    "tournamentName": "Basel",
    "tournamentUrl": "https://www.flashscore.com/tennis/atp-singles/basel/",
    "tournamentCountry": "Switzerland",
    "category": "ATP - Singles",
    "surface": "hard",
    "liveSet": null,
    "currentServer": null,
    "currentGameHome": null,
    "currentGameAway": null,
    "totalDurationMinutes": 120,
    "referee": "Absolu M.",
    "stats": [
      {
        "period": "Match",
        "group": "Service",
        "name": "Aces",
        "home": "18",
        "away": "5"
      },
      {
        "period": "Match",
        "group": "Service",
        "name": "Double Faults",
        "home": "2",
        "away": "4"
      },
      {
        "period": "Match",
        "group": "Service",
        "name": "1st serve percentage",
        "home": "78%",
        "away": "60%"
      }
    ],
    "headToHead": {
      "homeLastMatches": [
        {
          "matchId": "lljX5Uwp",
          "date": "2026-10-28T20:20:00.000Z",
          "tournament": "Basel",
          "surface": "hard",
          "home": "Hurkacz H.",
          "away": "Rune H.",
          "score": "1:2",
          "winner": "away"
        }
      ],
      "awayLastMatches": [
        {
          "matchId": "lljX5Uwp",
          "date": "2026-10-28T20:20:00.000Z",
          "tournament": "Basel",
          "surface": "hard",
          "home": "Hurkacz H.",
          "away": "Rune H.",
          "score": "1:2",
          "winner": "away"
        }
      ],
      "headToHead": [
        {
          "matchId": "lljX5Uwp",
          "date": "2026-10-28T20:20:00.000Z",
          "tournament": "Basel",
          "surface": "hard",
          "home": "Hurkacz H.",
          "away": "Rune H.",
          "score": "1:2",
          "winner": "away"
        }
      ]
    },
    "pointByPoint": [
      {
        "set": 1,
        "homeGames": 6,
        "awayGames": 3,
        "winner": "home",
        "games": [
          {
            "game": 1,
            "homeGames": 1,
            "awayGames": 0,
            "server": "home",
            "winner": "home",
            "brokeServe": false,
            "points": [
              {
                "score": "0:15",
                "markers": []
              },
              {
                "score": "15:15",
                "markers": []
              }
            ]
          },
          {
            "game": 2,
            "homeGames": 1,
            "awayGames": 1,
            "server": "away",
            "winner": "away",
            "brokeServe": false,
            "points": [
              {
                "score": "0:15",
                "markers": []
              },
              {
                "score": "15:15",
                "markers": []
              }
            ]
          }
        ],
        "tiebreak": null
      },
      {
        "set": 2,
        "homeGames": 3,
        "awayGames": 6,
        "winner": "away",
        "games": [
          {
            "game": 1,
            "homeGames": 0,
            "awayGames": 1,
            "server": "away",
            "winner": "away",
            "brokeServe": false,
            "points": [
              {
                "score": "15:0",
                "markers": []
              },
              {
                "score": "15:15",
                "markers": []
              }
            ]
          },
          {
            "game": 2,
            "homeGames": 1,
            "awayGames": 1,
            "server": "home",
            "winner": "home",
            "brokeServe": false,
            "points": [
              {
                "score": "15:0",
                "markers": []
              },
              {
                "score": "30:0",
                "markers": []
              }
            ]
          }
        ],
        "tiebreak": null
      }
    ],
    "source": "https://www.flashscore.com/tennis/",
    "scrapedAt": "2026-10-29T17:29:57.966Z"
  }
]
```

### 🔁 Scrape Flashscore tennis results and fixtures on a schedule

Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the scraper every day: set **Days back** to 1 to collect yesterday's finished matches, or **Days ahead** to 1 to collect the next day's fixtures. Matches that were saved in an earlier run are saved again, so remove duplicates by `matchId` when you merge runs.

### 🐍 How to scrape Flashscore tennis with Python, JavaScript or the API

Run the actor programmatically with the official Apify clients. Replace `<YOUR_API_TOKEN>` with the token from your [Apify Console](https://console.apify.com/account/integrations).

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("confidential_gnat/flashscore-tennis-scraper").call(run_input={
    "startUrls": [{"url": "https://www.flashscore.com/tennis/"}],
    "maxItems": 50,
    "daysBack": 1,
    "tours": ["atp", "wta"],
    "matchStatuses": ["finished"],
    "scrapeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('confidential_gnat/flashscore-tennis-scraper').call({
    startUrls: [{ url: 'https://www.flashscore.com/tennis/' }],
    maxItems: 50,
    daysBack: 1,
    tours: ['atp', 'wta'],
    matchStatuses: ['finished'],
    scrapeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**cURL** — start a run and wait for the dataset:

```bash
curl -X POST "https://api.apify.com/v2/acts/confidential_gnat~flashscore-tennis-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://www.flashscore.com/tennis/"}], "maxItems": 50, "daysBack": 1, "tours": ["atp", "wta"], "matchStatuses": ["finished"], "scrapeDetails": true}'
```

### 💡 What you can use Flashscore tennis data for

- Building tennis results and fixtures databases for rankings, Elo ratings and form models.
- Training and backtesting match prediction models on sets, tiebreaks, surface and head-to-head.
- Powering live score widgets, Discord or Telegram bots and fantasy tennis tools.
- Tracking player form by surface, tournament and ranking over time.
- Feeding sports media, newsletters and betting research with the day's matches and stats.

The data is typically used by sports analysts, data scientists, betting researchers, fantasy platforms and sports publishers.

### ⚠️ Limitations of the Flashscore tennis scraper

- **Seven days either side** — Flashscore lists about a week back and a week ahead, so older results are not available.
- **No round and no odds** — the round of the tournament and betting odds are not part of the output.
- **Details start with the match** — statistics and set durations exist only for live and finished matches, not for scheduled ones.
- **Point-by-point is game level** — it lists the points of each game as scores (the point that won the game is not listed) and does not carry shot types, aces or timestamps. Some old or minor matches have no point-by-point.
- **Doubles pairs** — a doubles side is one record with both player names joined, for example `Estevez J./Ratti L.`.

### ❓ Flashscore tennis scraper FAQ

#### Can I scrape Flashscore legally?

The actor only collects match data that is already publicly visible on Flashscore, with no login, paywall or private content. Scraping publicly available data is generally considered lawful (see *hiQ Labs v. LinkedIn*), but you are responsible for complying with Flashscore's Terms of Service and applicable laws.

#### What data does the Flashscore tennis scraper return?

Each match has its status, start and end time, sets and tiebreaks, winner, both players with country and ranking, the tournament with its category and surface, and for live matches the current set, server and game score. With **Scrape match details** you also get set durations, the referee and match statistics, with **Include head-to-head** the previous meetings and recent matches of the players, and with **Include point-by-point** every game of every set.

#### How many matches can I scrape from one Flashscore URL?

**Max matches per URL** limits the saved matches for each start URL, counted across all the days you selected. A normal day lists several hundred tennis matches including ITF events, so use the tour, status and tournament filters to narrow it down.

#### Do I need a proxy to scrape flashscore.com?

No. The input defaults to no proxy and runs worked without one in testing. Turn on Apify Proxy only if your runs start getting blocked.

#### How do I scrape Flashscore tennis with Python?

Use the Python example above: it starts the actor with your input and iterates over the dataset items.

#### Can I run this Flashscore tennis scraper on a schedule?

Yes. Create an Apify Schedule for the actor and set **Days back** to 1 to receive the previous day's results on every run.

#### What output formats are supported?

JSON, CSV, Excel, XML and RSS, either from the **Output** tab or through the Apify API.

#### Why are some stats and durations empty?

Statistics, set durations and the referee only exist once a match has started, so scheduled matches return `null` for them. Some lower-level ITF matches also have no statistics on Flashscore.

### 🔗 Relevant actors for tennis and sports data

| Scraper | Description |
| ------- | ----------- |
| [📈 Covers.com Odds, Line History & Betting Trends Scraper](https://apify.com/confidential_gnat/covers-odds-trends-scraper) | Covers.com odds, line history and betting trends for NFL, NBA, MLB and NHL. |
| [📊 StatMuse Sports Stats Scraper](https://apify.com/confidential_gnat/statmuse-sports-scraper) | StatMuse answers to natural-language sports questions plus player stats. |
| [🎯 Action Network Odds & Public Betting Scraper](https://apify.com/confidential_gnat/action-network-odds-scraper) | Sportsbook odds, public betting splits and line movement. |
| [🏈 DraftKings Sportsbook Odds & Player Props Scraper](https://apify.com/confidential_gnat/draftkings-odds-scraper) | DraftKings odds and player props for NBA, NFL, MLB, NHL, UFC and soccer. |
| [🏀 FanDuel Odds, Player Props & Same Game Parlay Scraper](https://apify.com/confidential_gnat/fanduel-odds-sgp-scraper) | FanDuel odds, player props and same game parlays. |

### 🔗 Other actors you may find useful

| Scraper | Description |
| ------- | ----------- |
| [🥾 AllTrails Scraper — Hiking, Biking & Running Trails](https://apify.com/confidential_gnat/alltrails-scraper) | Hiking, biking and running trails by park, city or state. |
| [📌 Pinterest Pins, Boards & Profiles Scraper](https://apify.com/confidential_gnat/pinterest-pins-scraper) | Pins, videos, boards and profiles from Pinterest searches and URLs. |
| [💼 Dice Jobs Scraper](https://apify.com/confidential_gnat/dice-jobs-scraper) | Tech job listings from Dice by keyword or URL. |
| [🔮 Kalshi Markets Scraper](https://apify.com/confidential_gnat/kalshi-markets-scraper) | Prediction market prices, implied probability and volume from Kalshi. |
| [🍷 Vivino Wine Scraper](https://apify.com/confidential_gnat/vivino-wine-scraper) | Wine data from Vivino: name, winery, vintage and ratings. |

### 💬 Support & contact

If you encounter any issues or have questions, please [open an issue](https://apify.com/confidential_gnat/flashscore-tennis-scraper/issues/open).

You can also find more of our actors on the [Actor Flow](https://apify.com/confidential_gnat) page.

# Actor input Schema

## `startUrls` (type: `array`):

The tennis page (https://www.flashscore.com/tennis/) for all matches, a tour or tournament page such as https://www.flashscore.com/tennis/atp-singles/paris/ to keep only its matches, or a match page with ?mid= for one match.

## `maxItems` (type: `integer`):

Maximum matches saved for each start URL.

## `daysBack` (type: `integer`):

Also scrape the matches of this many days before today (0 to 7). Finished matches are listed for a week.

## `daysAhead` (type: `integer`):

Also scrape the fixtures of this many days after today (0 to 7).

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

Keep only these tours. Empty means all.

## `matchStatuses` (type: `array`):

Keep only scheduled, live or finished matches (finished includes retired and walkover). Empty means all.

## `matchType` (type: `string`):

Keep singles, doubles or both.

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

Keep only tournaments whose name contains one of these words, for example Paris or Roland Garros.

## `scrapeDetails` (type: `boolean`):

Adds the duration of each set and of the match, the referee and the match statistics (aces, double faults, serve and return points, break points, winners, errors) for matches that have started. Not available for scheduled matches.

## `includeHeadToHead` (type: `boolean`):

Adds the previous meetings of the two players and the last matches of each player.

## `includePointByPoint` (type: `boolean`):

Adds every game of every set for matches that have started: who served, who won, whether the serve was broken, the points of the game (0:15, 30:40...) with break, set and match points flagged, and the tiebreak points in order. Not available for scheduled matches or for some old or minor matches.

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

No proxy is needed in normal use. Turn on Apify Proxy if your runs get blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.flashscore.com/tennis/"
    }
  ],
  "maxItems": 5,
  "daysBack": 0,
  "daysAhead": 0,
  "matchType": "all",
  "scrapeDetails": false,
  "includeHeadToHead": false,
  "includePointByPoint": false,
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.flashscore.com/tennis/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("confidential_gnat/flashscore-tennis-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.flashscore.com/tennis/" }],
    "proxyConfiguration": {
        "useApifyProxy": False,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("confidential_gnat/flashscore-tennis-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.flashscore.com/tennis/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call confidential_gnat/flashscore-tennis-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,confidential_gnat/flashscore-tennis-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dgf9kOOBtBVqMGMg6/builds/ffFI3GYfeBde9c5Jb/openapi.json