# Flashscore Scraper ($0.85/1K): Live Scores, Stats & Odds (`tsutseisoftware/flashscore-scraper`) Actor

Scrape Flashscore live scores, results and fixtures of 29 sports: football, tennis, basketball, hockey and more. Match stats with xG, lineups, events, H2H, standings, tennis rankings and bookmaker odds; date range, league or team filters, monitoring and alerts. Unofficial.

- **URL**: https://apify.com/tsutseisoftware/flashscore-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 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.
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 Scraper: Live Scores, Results, Stats & Odds

Get matches from **Flashscore** (flashscore.com, also Livesport.cz, Soccer24 and Tennis24) for **29 sports** as clean, ready-to-use data: **football, tennis, basketball, ice hockey**, American football, baseball, handball, volleyball, cricket, darts, snooker, esports, MMA and more. Every match comes with its country and competition, round, start time (UTC and your time zone), **status and live minute**, teams or players with their IDs, logos and URLs, **score, period scores** (halves, quarters, periods, sets with tie-breaks), winner and result type (after extra time, penalties, walkover, retired). Tennis matches add the **tour, singles or doubles, surface and both players' ATP or WTA ranking**.

Pick the **sports and days** (from 7 days back to 7 days ahead) and filter by status (live, finished, scheduled…), country, competition, team or player, top competitions only, tennis tour or surface, without qualification, with at most N matches per competition. Or paste **Flashscore URLs**: a competition with all its results and fixtures (**this season, the last N seasons or the seasons you list**), a team or player with their whole match history (or just **search them by name**), a competition **table** (overall, home, away, **form**, **over/under**), its **top scorers**, a **tennis ranking** or single matches.

Options add the **match details**: goals with scorers and assists, cards, substitutions and VAR by minute, referee, venue and attendance, **statistics with expected goals (xG)**, possession, shots, corners and the rest, **lineups** with formations, ratings and coaches, **injured and suspended players**, **every player's statistics** (rating, minutes, goals, xG, passes, duels… in top football competitions), **head-to-head and form**, tennis **point by point**, and the **odds** of every bookmaker with the average, best and opening odds and the **implied probabilities without the margin**, in decimal, fractional or American format, with only the handicap and over/under lines you need. Built for watching: schedule it in **monitoring mode** and you get, and pay for, only **new matches, goals, results and odds moves**, with an alert to Telegram, Slack, Discord, WhatsApp or your webhook.

**Price:** $0.85 per 1 000 matches (down to $0.55 on higher plans); match details $0.50 per 1 000 more, odds $1.00 per 1 000 more. 100 matches ≈ $0.09. No account and no extra platform costs.

> **Česky:** Scraper a API pro **Flashscore a Livesport.cz** (Livesport s.r.o.): **živé výsledky**, výsledky a program zápasů 29 sportů (fotbal, tenis, hokej, basketbal, florbal, házená, volejbal…), statistiky zápasu včetně **xG**, sestavy, zranění, vzájemné zápasy a forma, **tabulky soutěží**, žebříčky ATP a WTA a **kurzy sázkových kanceláří** s pravděpodobnostmi. Hlídání gólů, výsledků a pohybů kurzů s upozorněním na Telegram, Slack, Discord nebo WhatsApp. Export do Excelu, CSV nebo JSON.

### Why use this Flashscore scraper?

- **One actor for every sport:** 29 sports in one run, instead of a separate actor per sport, per feature or per league.
- **Under the most used Flashscore scrapers:** $0.85 per 1 000 matches, with every match detail $1.35, with odds too $2.35, no extra platform costs.
- **Days, competitions, seasons, teams, players, tables, top scorers, rankings and matches** in one input: today's matches, last week's results, the last ten Premier League seasons, a team's full history (by URL or name), the LaLiga home and away tables, the over/under table, the top scorers or the ATP ranking.
- **The data analysts and bettors need:** xG and all statistics, lineups and ratings, player statistics, missing players, H2H and form, period scores, form and over/under tables, and the odds of every bookmaker with fair probabilities and the margin.
- **Live and monitoring:** "Live" reads every match playing right now (also those that started before midnight); monitoring returns only what changed (goals, status, results, odds moves above your threshold), with alerts.
- **Clean, flat data:** numbers as numbers, ISO dates in UTC and in your time zone, stable IDs and URLs for matches, teams, players and competitions, ready for Excel, a database or a model.

| | This actor | Typical Flashscore scraper |
|---|---|---|
| Price per 1 000 matches | **$0.85** (+$0.50 details, +$1.00 odds) | $0.90–1.00, with details $3–11, with odds $3–5 |
| Sports | **29 in one run** | often one sport (tennis, football, basketball) |
| Days, the last N seasons, teams by URL or name, tables (home, away, form, over/under), top scorers, tennis rankings, match IDs | **yes, all in one input** | days or one URL type |
| Statistics with xG, lineups, player statistics, missing players, H2H, point by point | **yes** | some |
| Odds of every bookmaker, opening odds, fair probabilities, margin, bookmaker filter | **yes** | often separate actors or $3–5 / 1 000 |
| Monitoring of goals, results and odds moves, alerts | **yes** (Telegram, Slack, Discord, WhatsApp, webhook) | rarely |

### What data can you get?

| Field | Example |
|---|---|
| Match | id Eyc1EfPH, url, sport football, country England, competition Premier League, round "Round 10" |
| Time | startTime 2026-11-07T15:00:00Z, startTimeLocal (your time zone), matchDate 2026-11-07 |
| Status | status finished (scheduled, live, postponed, cancelled, interrupted, abandoned, delayed), statusText "After penalties", liveMinute "67'" |
| Teams or players | homeTeam Arsenal, awayTeam Hull, IDs, short codes, URLs, logos; tennis: country of the player and ATP/WTA ranking |
| Score | homeScore 1, awayScore 0, homePeriodScores \[0, 1], periodScoresText "0-0, 1-0" (extra time last), winner home, resultType normal, regular-time score after extra time, penalty shoot-out score |
| Tennis | tennisTour atp, tennisDraw singles, surface indoor hard, tie-breaks in the set scores ("7-6(4)"), point by point with every game, the tie-break points and break, set and match points marked |
| Match summary | incidents (goal, own goal, penalty goal, missed penalty, cards, substitution, VAR, penalty shoot-out kicks: minute, side, player, assist, score), referee, venue, city, capacity, attendance |
| Statistics | every statistic by period; football as columns: homeXg 1.26, awayXg 0.36, possession, shots, shots on target, big chances, corners, cards, fouls, offsides, saves |
| Lineups | formations, starting XI and substitutes with numbers, captain, goalkeeper, ratings and average rating, coaches, missing players with the reason |
| Player statistics | playerStatistics: every player's rating, minutes, goals, assists, shots, xG, xA, passes, touches, tackles, duels, saves, cards and 100+ more (top football competitions) |
| Head-to-head | last matches of both sides, earlier meetings, form "WWDLW", meetings won by each side |
| Odds | oddsHome 1.14, oddsDraw 8.0, oddsAway 18.2, best and opening odds, probabilityHome 83 %, oddsMarginPercent 5.9, bookmakers 20, every bookmaker's line (1X2, home/away, over/under, Asian and European handicap, both teams to score, double chance, draw no bet, correct score, half/full time, odd/even); only the bookmakers and lines you choose, only matches with odds; also as fractional (1/7) or American (-714) text |
| Tables and rankings | rowType standing or ranking: rank, team or player, matches, wins, draws, losses, goals, points, form, qualification zone; home, away, form (last 5 and 10) and over/under tables (matches over and under each goal line, goals per match); ranking points |
| Top scorers | rowType topScorer: rank, scorer, nationality, position, team, goals, assists |
| Raw data (option) | rawData: the match as Flashscore's list gives it |
| Monitoring | changeType new or updated, changedFields, previous status, score and odds |

Extra export formats: a printable HTML report or a Markdown table, besides Excel, CSV and JSON. **Output fields** keeps only the fields you list.

### How to scrape Flashscore

1. Choose the **sports** and the **days** (or paste Flashscore URLs, or match IDs).
2. Add filters if you want (status, countries, competitions, teams, top competitions only, tennis tours).
3. Turn on the **match details** and **odds** you need.
4. Run it, or schedule it in monitoring mode. Download the data as Excel, CSV or JSON, or connect it to your tools.

### Use cases

#### Today's football in the top leagues, with odds

```json
{
  "sports": ["football"],
  "dateFrom": "today",
  "topLeaguesOnly": true,
  "includeOdds": true,
  "oddsCountry": "GB",
  "maxItems": 200
}
```

#### Live scores of several sports, every few minutes, with alerts on goals

```json
{
  "sports": ["football", "hockey", "basketball"],
  "statuses": ["live"],
  "competitions": ["England: Premier League", "USA: NHL", "USA: NBA"],
  "onlyNewOrChanged": true,
  "monitoringKey": "live-big-leagues",
  "telegramBotToken": "123456789:AA...",
  "telegramChatId": "123456789",
  "maxItems": 0
}
```

#### A whole season for a betting model: results with xG, lineups and odds

```json
{
  "startUrls": [{ "url": "https://www.flashscore.com/football/england/premier-league-2025-2026/results/" }],
  "includeSummary": true,
  "includeStatistics": true,
  "includeLineups": true,
  "includeOdds": true,
  "oddsMarkets": ["HOME_DRAW_AWAY", "OVER_UNDER", "BOTH_TEAMS_TO_SCORE"],
  "maxItems": 0
}
```

#### ATP and WTA matches of the week with rankings, H2H and statistics

```json
{
  "sports": ["tennis"],
  "dateFrom": "-7",
  "dateTo": "today",
  "tennisTours": ["atp", "wta"],
  "tennisDraw": "singles",
  "statuses": ["finished"],
  "includeStatistics": true,
  "includeH2H": true,
  "maxItems": 500
}
```

#### Ten seasons of a league with tables and top scorers

```json
{
  "startUrls": [{ "url": "https://www.flashscore.com/football/germany/bundesliga/results/" }],
  "pastSeasons": 9,
  "includeStandings": true,
  "standingsViews": ["overall", "home", "away", "overUnder"],
  "includeTopScorers": true,
  "maxItems": 0
}
```

#### A team's matches by name, with player statistics

```json
{
  "searchTeams": ["Arsenal (football)", "Real Madrid (football)"],
  "statuses": ["finished"],
  "includePlayerStats": true,
  "maxItemsPerSource": 20,
  "maxItems": 0
}
```

#### A team's history, a table and a ranking

```json
{
  "startUrls": [
    { "url": "https://www.flashscore.com/team/arsenal/hA1Zm19f/" },
    { "url": "https://www.flashscore.com/football/spain/laliga/standings/" },
    { "url": "https://www.flashscore.com/tennis/rankings/atp/" }
  ],
  "maxItemsPerSource": 100,
  "maxItems": 0
}
```

#### Odds movements before kick-off

```json
{
  "sports": ["football"],
  "dateFrom": "today",
  "dateTo": "tomorrow",
  "statuses": ["scheduled"],
  "topLeaguesOnly": true,
  "includeOdds": true,
  "onlyNewOrChanged": true,
  "monitorOdds": true,
  "minOddsChangePercent": 5,
  "monitoringKey": "odds-moves",
  "maxItems": 0
}
```

#### Monitoring mode explained

With **Monitoring: only new or changed matches** on, the actor remembers every match it returned under your **Monitoring key**. The next run returns a match only when it is new or its status, score, period scores or start time changed (and with **Monitoring: odds changes**, when its main odds moved), with the previous status, score and odds. Unchanged matches are not returned and not charged; every list the run reads is charged as a monitoring page. With **Max results** set, monitoring watches the first matches of the lists in Flashscore's order, so a run without changes returns nothing. A watched match stays watched when its status changes, so with **Match status** "Live" you also get the final whistle (status finished). Odds moves under **Monitoring: min odds change** (2 % by default) are not returned; when the odds of a match cannot be read in a run, that is not reported as a change. Tables and rankings are monitored too (rank, points, matches). Schedule it every few minutes for live scores, or once a day for results.

#### Notifications

Add a Telegram bot, a Slack or Discord webhook, WhatsApp or any webhook URL, and every run sends one message with the saved matches: teams and score, competition, live minute or status with the period scores, the main odds and, in monitoring, what changed ("was 0-0").

#### Run summary (SUMMARY)

Every run writes a free summary to the key-value store: rows saved by sport and status, matches read and saved per day, URL or match, and the matches left out by each filter.

### How much does it cost to scrape Flashscore?

Pay per event, no subscription and no extra platform costs (compute and traffic are on us):

| Event | Free plan | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| Match (or table, top scorer or ranking row) | $0.85 / 1 000 | $0.75 / 1 000 | $0.65 / 1 000 | $0.55 / 1 000 |
| Match details (any of summary, statistics, lineups, player statistics, H2H, point by point) | $0.50 / 1 000 matches | same | same | same |
| Match odds (only matches with odds) | $1.00 / 1 000 matches | same | same | same |
| Actor start | $0.003 per run | same | same | same |
| Monitoring page (each list read in monitoring mode) | $0.0002 | same | same | same |
| Notification (a run that sent its message) | $0.001 | same | same | same |

Examples (Free plan): 100 matches ≈ $0.09; 1 000 matches with every match detail ≈ $1.35; 380 Premier League matches of a season with details and odds ≈ $0.90. A run that reads many lists for a narrow filter may add a small "extra page" charge ($0.0002 a list) so that it covers its cost; the log says what was charged.

### Input example

```json
{
  "sports": ["football", "tennis"],
  "dateFrom": "yesterday",
  "dateTo": "today",
  "statuses": ["finished"],
  "countries": ["England", "Spain", "ATP - Singles"],
  "includeStatistics": true,
  "maxItems": 100
}
```

### Output example

```json
{
  "id": "Eyc1EfPH",
  "rowType": "match",
  "source": "flashscore",
  "url": "https://www.flashscore.com/match/football/arsenal-hA1Zm19f/hull-city-S66R0t75/?mid=Eyc1EfPH",
  "sport": "football",
  "country": "England",
  "competition": "Premier League",
  "competitionId": "dYlOSQOD",
  "seasonId": "SY30SsKF",
  "competitionUrl": "https://www.flashscore.com/football/england/premier-league/",
  "round": "Round 10",
  "startTime": "2026-11-07T15:00:00Z",
  "startTimeLocal": "2026-11-07T15:00:00+00:00",
  "matchDate": "2026-11-07",
  "status": "finished",
  "statusText": "Finished",
  "homeTeam": "Arsenal",
  "awayTeam": "Hull",
  "homeTeamId": "hA1Zm19f",
  "awayTeamId": "S66R0t75",
  "homeScore": 1,
  "awayScore": 0,
  "homePeriodScores": [0, 1],
  "awayPeriodScores": [0, 0],
  "periodScoresText": "0-0, 1-0",
  "winner": "home",
  "resultType": "normal",
  "detailsIncluded": true,
  "incidents": [{ "period": "2nd Half", "minute": "72'", "side": "home", "type": "goal", "player": "Odegaard M.", "playerId": "ID32TGhp", "score": "1-0" }],
  "referee": "Hallam F.",
  "venue": "Emirates Stadium",
  "attendance": 60285,
  "homeXg": 1.26,
  "awayXg": 0.36,
  "homePossession": 67,
  "awayPossession": 33,
  "homeShotsOnTarget": 10,
  "awayShotsOnTarget": 2,
  "homeFormation": "4-2-3-1",
  "awayFormation": "5-3-2",
  "homeForm": "WWLWD",
  "awayForm": "DDLDL",
  "oddsIncluded": true,
  "oddsCountry": "GB",
  "oddsMarket": "HOME_DRAW_AWAY",
  "oddsHome": 1.138,
  "oddsDraw": 8.0,
  "oddsAway": 18.211,
  "probabilityHome": 83.0,
  "probabilityDraw": 11.8,
  "probabilityAway": 5.2,
  "oddsMarginPercent": 5.86,
  "oddsBookmakers": 20,
  "scrapedAt": "2026-11-18T10:00:00Z"
}
```

### Good to know

- **Days:** Flashscore lists matches from 7 days back to 7 days ahead. For older or later matches add the URL of a competition (results or fixtures of any season, e.g. `/football/england/premier-league-2024-2025/results/`) or of a team or player.
- **Sports and days are used when there are no Flashscore URLs or match IDs** in the input.
- **Scores:** the score is after extra time and without the penalty shoot-out (resultType afterPenalties and the winner tell who won); after extra time or penalties the regular-time score is in its own fields.
- **Head-to-head and form** are only the matches played before the match (the match itself and everything later are left out), so they are safe for prediction models. Flashscore gives the latest matches of both sides, so for a match of an older season the lists can be short or empty.
- **Penalty shoot-outs:** the score is after extra time; the shoot-out is in `homePenaltyScore` and `awayPenaltyScore`, and its kicks are incidents (shootoutGoal, shootoutMiss).
- **Round** is given for competition lists and matches read by URL or ID; the lists of a day and of a team do not carry it.
- **Live scores** are as fresh as Flashscore's own lists, which can be a minute or two behind the match page.
- **Odds of a finished match** are the last odds the bookmakers offered (closing odds), with the opening odds beside them.
- **Details only when the match has them:** no statistics, summary or point by point before the start; lineups appear about an hour before kick-off; a match is charged for details only when at least one of them was read, and for odds only when bookmakers offer them.
- **Odds** depend on the country (the bookmakers Flashscore shows there); the average, best and opening odds and the probabilities are of the main market (1X2, or home/away in sports without a draw) and of the bookmakers you chose.
- **Names** are as Flashscore writes them ("Manchester Utd", "Alcaraz C."); filter by team or player ID for an exact match. **Search teams or players** takes the first match of Flashscore's search in any sport; add the sport in brackets to narrow it ("Lakers (basketball)", "Arsenal (football)"). The log says which team or player each name became, so check it or use the URL.
- **Player statistics** are where Flashscore has them (mainly top football competitions); for other matches the list is empty and nothing is charged for it.
- **Seasons:** "Past seasons" and "Seasons" work with competition and table URLs and read each season like its own URL (results and fixtures, and its table and top scorers when turned on).
- **Tournaments and split leagues:** a season in several stages (Euro groups and play-offs, a league split into a championship and a relegation group) also gets the table of its last stage, and the top scorers count the whole tournament or season. Group tables have the group name in `group`.
- **Max matches per URL or day** limits the matches; the table and the top scorers of a competition URL each have the same limit of their own. In monitoring, "Max results" limits all rows that are watched, tables and top scorers included.
- **Not on Flashscore** and so not here: heatmaps, shot maps and fan votes; outright (tournament winner) odds Flashscore did not return when we checked; team and player names in other languages (the names are in English).

### For AI agents and API users

Call the actor with the Apify API or MCP server and a small JSON input (see the use cases); every row has `rowType`, stable `id` and `url`, ISO dates and numbers as numbers. Use `startUrls` for anything you can open on Flashscore, `matchIds` for known matches, `statuses: ["live"]` for live scores, and `onlyNewOrChanged` for repeated calls. The dataset also has the views "Odds lines" and "Incidents" with one row per bookmaker line or incident.

```bash
curl -X POST "https://api.apify.com/v2/acts/tsutseisoftware~flashscore-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sports": ["football"], "statuses": ["live"], "maxItems": 50}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("tsutseisoftware/flashscore-scraper").call(run_input={
    "sports": ["tennis"], "dateFrom": "today", "tennisTours": ["atp", "wta"], "includeOdds": True})
for match in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(match["homeTeam"], match["scoreText"], match["awayTeam"], match["oddsHome"], match["oddsAway"])
```

### Troubleshooting

- **No match passed the filters:** check the competition as Flashscore writes it ("England: Premier League", "Spain: LaLiga"), or use the competition URL.
- **"Flashscore lists matches from 7 days back to 7 days ahead":** use a competition or team URL for other dates.
- **Missing odds:** try another odds country; lower leagues and some sports have few bookmakers.
- **A run stopped early:** the status says why (Max results, your maximum cost per run, refused requests).

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### More sports data scrapers

Results, statistics and odds from another sports source:

- [TennisExplorer Scraper](https://apify.com/tsutseisoftware/tennisexplorer-scraper): tennis results back to 1990: sets and tiebreaks, odds of every bookmaker, value bets, H2H, rankings

### FAQ

#### Is it legal to scrape Flashscore?

The actor reads only data Flashscore shows to every visitor without logging in: match results, fixtures, statistics and odds, which are facts about public sports events. It saves no personal data beyond the names of players, coaches and referees as they appear in public match reports. You are responsible for how you use the data, including the terms of Flashscore and the laws of your country. This actor is not affiliated with Flashscore or Livesport.

#### How is it different from other Flashscore scrapers?

It covers 29 sports in one run, reads days, competitions of any season, teams, players, tables, tennis rankings and single matches, adds xG, lineups, missing players, H2H, point by point and the odds of every bookmaker with fair probabilities, and monitors goals, results and odds moves with alerts, for less than most single-sport scrapers.

#### Do I need a proxy?

No. The default works without a proxy.

#### How fresh are live scores?

As fresh as on Flashscore when the run reads them. For live scores schedule the actor every 1 to 5 minutes in monitoring mode, so each run returns and charges only the matches whose score or status changed.

#### Can I get historical data?

Yes, through competition URLs: open a past season on Flashscore (Archive), copy the URL of its results and paste it. Team and player URLs give their match history.

#### Which bookmakers are included?

The bookmakers Flashscore shows for the chosen odds country (for GB e.g. bet365, William Hill, Betfair, Paddy Power, Ladbrokes, Coral, Betfred, Betway, BetVictor, Sky Bet and others, 20 for a Premier League match); each line has the bookmaker's name.

This actor is also known as a Flashscore API, Flashscore live score scraper, Flashscore odds scraper, Livesport scraper (Czech: "výsledky Livesport", "živé výsledky") and Soccer24 or Tennis24 scraper.

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/flashscore-scraper/changelog.md

# Actor input Schema

## `sports` (type: `array`):

The sports whose matches to read for the chosen days. Used when there are no Flashscore URLs or match IDs below.

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

First day: a date (2026-11-18), today, yesterday, tomorrow, or days from today (-3 = three days ago, +2 = in two days). Flashscore lists matches from 7 days back to 7 days ahead; for older or later matches add a competition or team URL.

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

Last day, in the same forms (empty = the same day as "Date from").

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

Only matches with these statuses (empty = all). "Live" alone, without dates, reads every match playing right now, including those that started before midnight.

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

Maximum number of rows saved (matches, table or ranking rows). You pay per saved row. 0 = no limit.

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

Pages copied from Flashscore (also Livesport, Soccer24, Tennis24 and other Flashscore websites): a competition with its results and fixtures (https://www.flashscore.com/football/england/premier-league/, add /results/ or /fixtures/ for one of them, or a past season like .../premier-league-2024-2025/results/), a team or player (https://www.flashscore.com/team/arsenal/hA1Zm19f/), a competition table (.../premier-league/standings/), a tennis ranking (https://www.flashscore.com/tennis/rankings/atp/) or a match (https://www.flashscore.com/match/football/arsenal-hA1Zm19f/hull-city-S66R0t75/?mid=Eyc1EfPH).

## `matchIds` (type: `array`):

Flashscore match IDs (8 letters and digits, the mid= of a match URL, e.g. Eyc1EfPH).

## `searchTeams` (type: `array`):

Names of teams or players (Arsenal, Real Madrid, Alcaraz): the first one Flashscore's search finds in any sport is read like a team URL, with its past and future matches. Add the sport in brackets to narrow it: "Lakers (basketball)", "Arsenal (football)". The log says which team or player each name became.

## `dayOffsets` (type: `array`):

Days relative to today, as an alternative to "Date from" and "Date to" (e.g. Yesterday and Today).

## `countries` (type: `array`):

Only competitions of these countries or areas, as Flashscore names them (England, Spain, Europe, World; tennis: ATP - Singles, WTA - Singles, Challenger Men - Singles...).

## `competitions` (type: `array`):

Only these competitions: "England: Premier League" (country and name as on Flashscore), "Premier League" (the name in any country), a competition URL or path (/football/spain/laliga/) or its ID.

## `excludeCompetitions` (type: `array`):

Leave out these competitions (same forms as "Competitions"), e.g. "World: Club Friendly".

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

Only matches of these teams or players: a name (whole words, case and accents ignored: Arsenal, Real Madrid, Alcaraz) or a Flashscore team or player ID (hA1Zm19f). Add a team URL above for all its past and future matches.

## `topLeaguesOnly` (type: `boolean`):

Only the competitions Flashscore lists as its top competitions of the sport (Premier League, LaLiga, Champions League, NBA, NHL, Grand Slams...).

## `excludeWomenAndYouth` (type: `boolean`):

Leave out women's competitions and youth, reserve and amateur teams (U21, U19, II, B...); tennis: only the men's tours.

## `tennisTours` (type: `array`):

Tennis: only these tours (empty = all).

## `tennisDraw` (type: `string`):

Tennis: singles, doubles or both.

## `surfaces` (type: `array`):

Tennis: only tournaments on these surfaces (empty = all).

## `excludeQualification` (type: `boolean`):

Leave out qualification rounds and qualifying tournaments (tennis qualifying, World Cup qualification...).

## `includeSummary` (type: `boolean`):

Goals with scorers and assists, cards, substitutions, VAR and missed penalties by minute, the score of each period, referee, venue, city, capacity and attendance.

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

Match statistics by period as Flashscore shows them (football: expected goals xG, possession, shots, shots on target, big chances, corners, cards, fouls, offsides, saves, passes...; tennis: aces, double faults, serve and return points, break points; other sports their own), with the main football numbers also as columns.

## `includeLineups` (type: `boolean`):

Team sports: formations, starting players and substitutes with shirt numbers, captain, goalkeeper and player ratings, coaches, and injured or suspended players with the reason.

## `includeH2H` (type: `boolean`):

The last matches of both sides with results, their earlier meetings, form (W/D/L of the last 5) and how many meetings each side won.

## `h2hLimit` (type: `integer`):

How many last matches and meetings to keep per side.

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

Tennis: every game with the score, who served, breaks and the points of the game.

## `includePlayerStats` (type: `boolean`):

Team sports, where Flashscore has them (top football competitions): every player's rating, minutes, goals, assists, shots, expected goals and assists, passes, touches, tackles, duels, saves and cards, plus all 100+ statistics Flashscore shows, in "Player statistics".

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

Average, best and opening odds of the main market (1X2 or home/away), the implied probabilities without the bookmakers' margin, the margin, and every bookmaker's odds of the markets below.

## `oddsCountry` (type: `string`):

The bookmakers differ by country (as on Flashscore from that country): GB, DE, US-NJ, BR, IN...

## `oddsMarkets` (type: `array`):

Markets whose odds of every bookmaker go to "Odds lines" (the main summary is always 1X2 or home/away).

## `oddsPeriods` (type: `array`):

Parts of the match for the odds lines.

## `oddsBookmakers` (type: `array`):

Only these bookmakers (names as on Flashscore, e.g. bet365, William Hill, Betfair; case ignored). The average, best and opening odds and the probabilities are then of these bookmakers. Empty = all.

## `onlyWithOdds` (type: `boolean`):

Save only matches that have odds (of the chosen bookmakers); the others are not saved and not charged.

## `oddsLineValues` (type: `array`):

Only these lines of the handicap and over/under markets (e.g. 2.5 for over/under 2.5 goals, 1.5 for handicap +1.5 and -1.5). Markets without a line stay. Empty = all lines.

## `oddsFormat` (type: `string`):

Also give the odds in this format, as text next to the decimal numbers (oddsHomeText, oddsText in the odds lines). Decimal = numbers only.

## `includeStandings` (type: `boolean`):

Also save the table (rank, matches, wins, draws, losses, goals, points, form and the qualification or relegation zone) as rows of the type "standing".

## `standingsViews` (type: `array`):

Which tables to save: overall, home and away matches only, the form tables of the last 5 and 10 matches, or the over/under table (matches over and under each goal line, goals per match). Also for table URLs.

## `includeTopScorers` (type: `boolean`):

Also save the competition's top scorers (rank, player, nationality, position, team, goals, assists) as rows of the type "topScorer". Also for table URLs.

## `pastSeasons` (type: `integer`):

Also read this many seasons before the one in each competition or table URL (e.g. 5 = the last five completed seasons too), with their results, tables and top scorers if turned on.

## `seasons` (type: `array`):

Read these seasons of each competition or table URL instead of the one in the URL: 2024/2025, 2024-25 or 2024 (a season that starts in 2024).

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

Time zone of the dates: which matches belong to a day, the local start time and the match date (e.g. Europe/London, Europe/Prague, America/New_York). Start times are also always given in UTC.

## `outputFields` (type: `array`):

Save only these fields (names as in the output, e.g. homeTeam, awayTeam, homeScore, awayScore, startTime, oddsHome); id, url, source, rowType and scrapedAt are always kept, and rawData with "Include raw Flashscore data". Empty = all fields.

## `includeRawData` (type: `boolean`):

Adds the match exactly as Flashscore's list gives it (its short field codes) in the field rawData, for your own processing.

## `maxItemsPerSource` (type: `integer`):

Maximum per Flashscore URL or per sport and day. Empty = no limit.

## `maxMatchesPerCompetition` (type: `integer`):

Maximum matches saved per competition (e.g. 10 = at most 10 matches of each league of the day). Empty = no limit.

## `onlyNewOrChanged` (type: `boolean`):

Return new matches, and matches whose status, score, period scores or start time changed, with the previous status and score.

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for every saved search. Empty = "default".

## `monitorOdds` (type: `boolean`):

With "Add odds": also return matches whose main odds moved, with the previous odds.

## `minOddsChangePercent` (type: `number`):

With "Monitoring: odds changes": only odds that moved at least this much (default 2 %, 0 = every move).

## `onlyNew` (type: `boolean`):

Return new matches only, not changed ones.

## `skipFirstRun` (type: `boolean`):

The first run only remembers the matches and returns nothing; later runs return what changed.

## `resetMonitoring` (type: `boolean`):

Forget the remembered matches of this Monitoring key.

## `telegramBotToken` (type: `string`):

Token of your bot from @BotFather.

## `telegramChatId` (type: `string`):

Chat, group or channel to send to (e.g. 123456789 or -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook (https://hooks.slack.com/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): receives the matches as JSON.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many matches the message lists.

## `notifyOnlyChanges` (type: `boolean`):

No message after a run that saved nothing.

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

No proxy needed. If Flashscore keeps refusing your runs, switch to Apify Proxy; a run through a residential proxy may be charged a little more to cover its traffic.

## `exportFormats` (type: `array`):

Off by default. Printable HTML report: the results as a clean, branded table with the main columns, made for printing, saving as PDF or sending to someone; for working with the data use Excel or CSV, which have every field. Markdown table: the same columns as text for AI tools, docs or GitHub. The Output tab links the files. Each file has the overview columns of every saved row and nothing is left out, so a run with tens of thousands of rows makes a file of tens of MB that can be slow to open; for big runs use the dataset or its Excel export. Excel (XLSX), CSV and JSON are always in the Output tab and under Export, at no extra cost.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "sports": [
    "football"
  ],
  "dateFrom": "today",
  "maxItems": 20,
  "topLeaguesOnly": false,
  "excludeWomenAndYouth": false,
  "tennisDraw": "all",
  "excludeQualification": false,
  "includeSummary": false,
  "includeStatistics": false,
  "includeLineups": false,
  "includeH2H": false,
  "h2hLimit": 10,
  "includePointByPoint": false,
  "includePlayerStats": false,
  "includeOdds": false,
  "oddsCountry": "GB",
  "oddsMarkets": [
    "HOME_DRAW_AWAY",
    "HOME_AWAY"
  ],
  "oddsPeriods": [
    "FULL_TIME",
    "FULL_TIME_INCLUDING_OT"
  ],
  "onlyWithOdds": false,
  "oddsFormat": "decimal",
  "includeStandings": false,
  "standingsViews": [
    "overall"
  ],
  "includeTopScorers": false,
  "timezone": "UTC",
  "includeRawData": false,
  "onlyNewOrChanged": false,
  "monitorOdds": false,
  "minOddsChangePercent": 2,
  "onlyNew": false,
  "skipFirstRun": false,
  "resetMonitoring": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "exportFormats": [],
  "sendErrorReports": true
}
```

# Actor output Schema

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

No description

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

No description

## `excel` (type: `string`):

All saved rows as an Excel file, with every field.

## `htmlReport` (type: `string`):

The saved rows with the main columns as a clean table to print, save as PDF or send; only when "Extra export formats" includes it. Excel has every field.

## `markdown` (type: `string`):

The saved rows as a Markdown table, handy for AI tools, docs and GitHub; only when "Extra export formats" includes Markdown.

# 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 = {
    "sports": [
        "football"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/flashscore-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 = {
    "sports": ["football"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/flashscore-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 '{
  "sports": [
    "football"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/flashscore-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/flashscore-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/l1Ma1D4XTrJwn1azV/builds/8iTw6YIM3OFb6ICIn/openapi.json
