# Flashscore Scraper: Live Scores, Results & Odds (`panix/flashscore-scraper`) Actor

Scrape Flashscore for 29 sports: fixtures, live scores and results with every period, plus goals, cards, stats, lineups, injuries, odds, head-to-head, tennis point-by-point and league tables. For betting models, odds tracking, live score apps and fantasy. Only-changed mode for live polling.

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

## Pricing

from $0.60 / 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 & Odds

Fixtures, live scores and results from Flashscore for **29 sports** in one run, with every period score. Turn on extras when you need them: goals and cards, statistics with xG, lineups, injured players, betting odds from up to 20 bookmakers, head-to-head, tennis point-by-point and league tables.

No Flashscore account, API key or browser. Today's full football list (about 1,500 matches) takes about 10 seconds, and you pay only for the matches you receive.

### What you can do with it

- ⚽ **Pick sports and days** (7 days back to 7 days ahead) in your own time zone, or a date range.
- 🏆 **Paste Flashscore URLs:** a league (whole season, also past seasons), a team, a single match, or a league table.
- 🔎 **Filter before you pay:** match status, country or tour, competition, team or player, top leagues only.
- 📊 **Add match details:** goals with assists and the score after each goal, cards with the reason, substitutions, statistics per half or period, lineups with ratings and formations, predicted lineups before kick-off, injured and suspended players, odds with opening price and movement, head-to-head and form, tennis point-by-point.
- 📋 **League tables** with groups, conferences and divisions, points, goals and the last 5 results.
- 🔔 **Live polling:** schedule a run every minute and receive only matches whose score, status or kick-off time changed. Unchanged matches are free.
- 🤖 **AI-ready:** an optional Markdown summary per match for ChatGPT, Claude, chat bots or a RAG pipeline.

### Who uses it

- **Bettors and betting analysts:** results, xG, line movement and closing odds for models and backtests.
- **Odds comparison and tipster sites:** pre-match prices from every bookmaker Flashscore shows in a country.
- **Live score apps, widgets and bots** (Telegram, Discord, Slack): scheduled snapshots with only the changes.
- **Fantasy and prediction games:** fixtures, lineups, injuries, goals, assists and cards to score entries.
- **Sports media and newsletters:** daily results, scorers, venues and tables for automated reports.
- **Data scientists and AI teams:** clean JSON for models and dashboards, Markdown for LLM agents.

### Why this scraper

- **29 sports, one format:** football, tennis, basketball, ice hockey, cricket, baseball, American football, volleyball, handball, rugby, darts, esports and more, all with the same fields.
- **Every way in, in one run:** sports and days, a date range, league, team and match URLs, and match IDs together. A match found in several places is delivered and charged once.
- **Scores you can trust:** every period, tennis tiebreaks, extra time, shoot-outs, walkovers, retirements and awarded matches are labelled. Cricket gets runs, wickets, overs and the match situation; baseball gets hits and errors; MMA and boxing get the method and round.
- **Fresh live data:** today's and yesterday's lists are read at most about 10 seconds old.
- **One charge for all details:** a match with details costs the same whether you add one section or all of them, and only when at least one section returned data.
- **Results while it runs**, plus a SUMMARY record that explains each source: matches found, delivered, left out by each filter, and errors.

#### Coming from another Flashscore or sports scraper?

| Common problem | How this Actor handles it |
|---|---|
| One sport per scraper, each with its own fields | 29 sports in one run with one output format |
| Live scores a few minutes old | Today's and yesterday's lists are fetched fresh, at most about 10 seconds old |
| Polling charges every unchanged match again | Only-changed mode: unchanged matches are free |
| The shoot-out winner's extra goal counted in the football score | Official score, shoot-out result and level score kept apart |
| Separate runs or separate charges for stats, lineups and odds | One match-details charge per match, whatever you turn on |
| Charged when a match has no statistics or odds | Details are charged only when a section returned data |
| Nothing older than the 15-day window | League URLs return whole seasons, including past seasons |
| Days cut at UTC midnight | Days follow your time zone, including half-hour zones such as India |
| "Premier League" also returns the Premier League Cup | `England: Premier League` matches exactly that league; team names match whole words |
| Head-to-head lists that include the match itself | Form and meetings before the match only |

**Reliability.** Every failed request is retried from a new IP address, and Flashscore's three feed servers are tried in turn. If Flashscore changes the key its own website uses to read the feeds, the Actor reads the new key from Flashscore's JavaScript and carries on. A source that still fails (for example a mistyped URL) is listed in the SUMMARY with a reason and is never charged; the rest of the run continues. After an Apify platform restart, the run resumes where it stopped without charging twice.

### Supported sports

| Sports | Period scores | Extras |
|---|---|---|
| Football (soccer) | 1st and 2nd half | Extra time, shoot-out, xG, lineups, predicted lineups, injuries |
| Tennis | Sets with tiebreaks | Live game points and server, tour, surface, singles or doubles, point-by-point |
| Basketball, ice hockey | Quarters or periods, overtime | Lineups, injuries, shoot-out |
| American football, Aussie rules, water polo, netball | Quarters | |
| Baseball | Innings | Hits, errors, pitchers' win and loss |
| Cricket | Innings | Runs, wickets, overs, run rate, match situation ("require another 180 runs with 9 wickets and 101 balls remaining") |
| Volleyball, beach volleyball, table tennis, badminton, darts | Sets | |
| Handball, rugby union, rugby league, futsal, field hockey, bandy, kabaddi | Halves | |
| Floorball, beach soccer | Periods | |
| Snooker, esports (maps), boxing, MMA, pesäpallo | | Fight method and round for boxing and MMA |

### How to use it

1. Click **Try for free** and open the **Input** tab.
2. Pick **Sports** and **Days**, or paste Flashscore URLs or match IDs. Leave everything empty for today's football.
3. Optionally narrow it down with the filters and turn on the match details you need.
4. Set **Max matches** to cap the run (a full day of football has about 1,500 matches), then click **Start**.
5. Download as JSON, CSV, Excel or HTML, or connect the results to your tools (see API and integrations below).

### Input examples

**Today's football in the top leagues, live and finished**

```json
{
  "sports": ["football"],
  "days": ["0"],
  "topLeaguesOnly": true,
  "statuses": ["live", "finished"]
}
```

**Yesterday's Premier League with goals, statistics, lineups and the table**

```json
{
  "sports": ["football"],
  "days": ["-1"],
  "competitions": ["England: Premier League"],
  "includeIncidents": true,
  "includeStatistics": true,
  "includeLineups": true,
  "includeStandings": true
}
```

**Tomorrow's matches with odds and injured players, with New Jersey bookmakers**

```json
{
  "sports": ["football", "basketball", "hockey"],
  "days": ["1"],
  "topLeaguesOnly": true,
  "includeOdds": true,
  "oddsCountry": "US-NJ",
  "oddsMarkets": ["HOME_DRAW_AWAY", "HOME_AWAY", "OVER_UNDER"],
  "includeMissingPlayers": true
}
```

**Live ATP and WTA scores every minute, only what changed** (add a schedule in Apify)

```json
{
  "sports": ["tennis"],
  "days": ["0"],
  "statuses": ["live", "finished"],
  "countries": ["ATP", "WTA"],
  "onlyChanged": true,
  "monitorName": "tennis-live"
}
```

**A whole past season and its final table**

```json
{
  "urls": ["https://www.flashscore.com/football/england/premier-league-2024-2025/"],
  "maxMatchesPerLeague": 0,
  "includeStandings": true
}
```

**Details for matches you already have**, by URL or by the `matchId` of an earlier run

```json
{
  "matchIds": ["OWc65atm", "xntwYHUH"],
  "urls": ["https://www.flashscore.com/match/football/chelsea-4fGZN2oK/manchester-united-ppjDR086/?mid=OWc65atm"],
  "includeIncidents": true,
  "includeStatistics": true,
  "includeH2H": true,
  "includePointByPoint": true
}
```

**Cricket in Indian time**

```json
{
  "sports": ["cricket"],
  "days": ["0", "1"],
  "timezone": "Asia/Kolkata"
}
```

### Output

One row per match. The main fields:

| Field | Example | Notes |
|---|---|---|
| `matchId`, `url` | `OWc65atm` | Flashscore's match ID and page |
| `sport`, `country`, `competition`, `round` | `football`, `England`, `Premier League` | `country` is the tour for tennis (`ATP - Singles`); `round` comes with league URLs |
| `startTime`, `localStartTime`, `localDate` | `2026-10-31T12:30:00Z` | UTC, and in the time zone you chose |
| `status` | `finished` | `scheduled`, `live`, `finished`, `postponed`, `cancelled`, `interrupted`, `abandoned`, `delayed` |
| `statusDetail` | `2nd half`, `After penalties`, `Set 3` | Flashscore's own stage name |
| `resultType` | `regular` | `extra_time`, `penalties`, `walkover`, `retired`, `awarded` |
| `homeTeam`, `awayTeam`, `homeScore`, `awayScore`, `scoreText`, `winner` | `2-0`, `home` | `winner` is `home`, `away` or `draw` |
| `score.periods` | `[{"name": "1st half", "home": 0, "away": 0}, ...]` | With tiebreaks for tennis |
| `live` | `{"minute": "67'"}` | Live minute, or tennis game points and server |
| `home`, `away` | team or player ID, URL, logo, short name, country | Doubles list both players |
| `incidents`, `statistics`, `lineups`, `predictedLineups`, `missingPlayers`, `odds`, `h2h`, `pointByPoint` | | When the matching option is on |
| `matchInfo` | venue, city, attendance, capacity, referee | Added free with goals and cards |
| `detailsStatus` | `{"odds": "ok", "lineups": "not_available"}` | Which detail sections returned data |
| `changeType`, `changedFields` | `updated`, `["score"]` | With a monitor name |

A real row from a run on 1 November 2026 (all match details on; lists shortened to one or two items):

```json
{
  "matchId": "OWc65atm",
  "url": "https://www.flashscore.com/match/football/chelsea-4fGZN2oK/manchester-united-ppjDR086/?mid=OWc65atm",
  "sport": "football",
  "country": "England",
  "competition": "Premier League",
  "startTime": "2026-10-31T12:30:00Z",
  "localDate": "2026-10-31",
  "status": "finished",
  "statusDetail": "Finished",
  "resultType": "regular",
  "homeTeam": "Chelsea",
  "awayTeam": "Manchester Utd",
  "homeScore": 2,
  "awayScore": 0,
  "scoreText": "2-0",
  "winner": "home",
  "home": {"name": "Chelsea", "shortName": "CHE", "id": "4fGZN2oK", "url": "https://www.flashscore.com/team/chelsea/4fGZN2oK/",
           "logo": "https://static.flashscore.com/res/image/data/lMxEQ8me-vcRg8e0j.png"},
  "away": {"name": "Manchester Utd", "shortName": "MNU", "id": "ppjDR086", "redCards": 1,
           "url": "https://www.flashscore.com/team/manchester-united/ppjDR086/"},
  "score": {"home": 2, "away": 0, "regularTime": {"home": 2, "away": 0},
            "periods": [{"period": 1, "name": "1st half", "home": 0, "away": 0},
                        {"period": 2, "name": "2nd half", "home": 2, "away": 0}]},
  "endTime": "2026-10-31T14:30:01Z",
  "incidents": [
    {"minute": "50'", "side": "home", "type": "goal", "player": "Rogers M.", "assist": "Lavia R.",
     "scoreAfter": {"home": 1, "away": 0}, "playerUrl": "https://www.flashscore.com/player/rogers-morgan/lp4jm80n/"},
    {"minute": "59'", "side": "away", "type": "yellow_card", "player": "Martinez Li.", "reason": "Holding"},
    {"minute": "64'", "side": "home", "type": "penalty_goal", "player": "Palmer C.", "scoreAfter": {"home": 2, "away": 0},
     "related": [{"type": "penalty_awarded", "label": "Penalty Awarded", "player": "Palmer C."}]}
  ],
  "matchInfo": {"referee": "Bankes P.", "refereeCountry": "Eng", "venue": "Stamford Bridge", "city": "London", "capacity": 40341},
  "statistics": [
    {"period": "Match", "group": "Top stats", "name": "Expected goals (xG)", "home": "2.67", "away": "1.17", "homeValue": 2.67, "awayValue": 1.17},
    {"period": "Match", "group": "Top stats", "name": "Ball possession", "home": "58%", "away": "42%", "homeValue": 58, "awayValue": 42}
  ],
  "lineups": {
    "home": {"formation": "1-4-2-3-1", "averageRating": 7.5,
             "starters": [{"name": "Acheampong J.", "number": 34, "country": "England", "rating": 8.4, "bestPlayerRank": 2}],
             "substitutes": [{"name": "Barco V.", "number": 4, "events": [{"type": "substituted_in", "minute": "87'", "replaced": "Neto P."}]}],
             "coaches": [{"name": "Alonso X.", "country": "Spain"}]},
    "away": {"formation": "1-4-2-3-1", "averageRating": 6.3, "...": "..."}
  },
  "missingPlayers": {"home": [{"name": "Anselmino A.", "reason": "Injury", "doubtful": false}],
                     "away": [{"name": "Dorgu P.", "reason": "Hamstring Injury", "doubtful": false}]},
  "odds": [
    {"market": "HOME_DRAW_AWAY", "scope": "FULL_TIME",
     "bookmakers": [{"bookmaker": "10bet", "prices": [
       {"selection": "home", "odds": 2.28, "opening": 2.1, "movement": "up", "result": "won"},
       {"selection": "away", "odds": 2.92, "opening": 3.1, "movement": "down", "result": "lost"},
       {"selection": "draw", "odds": 3.7, "opening": 3.7, "result": "lost"}]}]}
  ],
  "oddsCountry": "GB",
  "h2h": {"homeLastMatches": [{"date": "2026-10-28T20:00:00Z", "competition": "EFL Cup", "homeTeam": "Liverpool",
                               "awayTeam": "Chelsea", "score": "2:1", "result": "loss"}],
          "awayLastMatches": [{"date": "2026-10-25T14:00:00Z", "homeTeam": "Manchester Utd", "awayTeam": "Bournemouth",
                               "score": "0:3", "result": "loss"}],
          "headToHead": [{"date": "2026-04-18T19:00:00Z", "homeTeam": "Chelsea", "awayTeam": "Manchester Utd", "score": "0:1"}]},
  "detailsStatus": {"incidents": "ok", "statistics": "ok", "lineups": "ok", "missingPlayers": "ok", "odds": "ok", "h2h": "ok"},
  "detailsDelivered": true,
  "scrapedAt": "2026-11-01T15:08:43Z"
}
```

**League tables** come as extra rows with `"type": "standings"`: the competition, and one table per group (conference, division or World Cup group) with rank, team, played, wins, draws, losses, goals, points and the last results as `["W", "W", "L", "D", "W"]`.

**SUMMARY** (key-value store): per source, the matches found and delivered, matches left out by each filter, detail sections that returned data, errors with a code, and the nearest days with matches when a day was empty.

### Pricing

Pay per result: you pay for matches delivered to your dataset, nothing else.

| Apify plan | Per 1,000 matches | Match details, per 1,000 matches | League table, each |
|---|---|---|---|
| Free | $0.90 | $3.00 | $0.003 |
| Starter | $0.80 | $2.50 | $0.0025 |
| Scale | $0.70 | $2.00 | $0.002 |
| Business and higher | $0.60 | $1.50 | $0.0015 |

- **Actor start:** $0.001 per run.
- **Match details** are one charge per match for all the detail options you turn on, and only when at least one of them returned data.
- **Never charged:** failed sources, duplicates, matches removed by your filters, unchanged matches in only-changed mode, and detail sections Flashscore does not have.
- **Examples (Starter):** a day of tennis, 150 to 300 matches = $0.12 to $0.24. Every football match of a Saturday, about 1,800 = $1.44. 20 Premier League matches with statistics, lineups and odds = $0.067. A whole Premier League season (380 matches) and its table = $0.31. A scheduled live check that finds nothing new = $0.001.
- Set a **maximum cost per run** in Run options; the run stops cleanly at that amount and keeps everything delivered so far.

### Good to know

- **Days:** Flashscore's daily lists cover 7 days back to 7 days ahead. For older matches paste a league URL; past seasons have their own URL, such as `.../premier-league-2024-2025/`.
- **Team pages** return about the last 40 results and every upcoming fixture.
- **Snapshots:** each run reads the current state. For a live feed, schedule the Actor every minute with **Only new or changed matches** on.
- **Live minute** for football is counted from the start of the half, as on the site, and shows `45+` or `90+` in added time.
- **Odds** are pre-match prices (opening and latest) from the bookmakers Flashscore shows in the chosen country: about 20 in Great Britain, fewer in most other countries. After kick-off the latest price is the closing line, and finished matches mark each selection as won or lost.
- **Details depend on the competition:** major leagues have statistics, lineups, injuries and odds; small leagues often have only the score. Sections without data are marked `not_available` in `detailsStatus` and are not charged.
- **Football shoot-outs:** `homeScore` and `awayScore` are the official score (level after extra time) and `score.penalties` has the shoot-out; `score.displayed` keeps Flashscore's display, which adds a goal for the shoot-out winner. In ice hockey and floorball that goal counts, so the score keeps it.
- **Not supported yet:** golf, motor racing, cycling, horse racing and winter sports, which have rankings instead of matches. Point-by-point is for tennis only.

### API and integrations

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

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/flashscore-scraper").call(run_input={
    "sports": ["football", "tennis"],
    "days": ["0"],
    "statuses": ["finished"],
    "maxItems": 500,
})
for match in client.dataset(run.default_dataset_id).iterate_items():
    print(match["competition"], match["homeTeam"], match["scoreText"], match["awayTeam"])
```

**JavaScript / Node.js** (`npm install apify-client`)

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/flashscore-scraper').call({
    sports: ['basketball'],
    days: ['0'],
    competitions: ['USA: NBA'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((m) => `${m.homeTeam} ${m.scoreText ?? 'vs'} ${m.awayTeam}`));
```

**cURL** (runs and returns the matches in one call, for runs up to 5 minutes)

```bash
curl -X POST "https://api.apify.com/v2/acts/panix~flashscore-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"sports": ["football"], "days": ["0"], "topLeaguesOnly": true}'
```

**No-code tools**

- **n8n:** in the Apify node, run the Actor `panix/flashscore-scraper` with the input JSON, then read the run's dataset items.
- **Make:** Apify app → *Run an Actor* (wait until it finishes) → *Get Dataset Items*.
- **Zapier:** Apify app → *Run Actor* action, then fetch the dataset items of that run.
- **Google Sheets, Slack, webhooks:** under the Actor's **Integrations** tab. Combine a schedule with only-changed mode for goal and result alerts.

**AI agents (MCP):** add `https://mcp.apify.com/?actors=panix/flashscore-scraper` to Claude, Cursor or any MCP client and ask, for example, "Who scored in yesterday's Premier League matches, and what was the xG?"

### FAQ

**Do I need a Flashscore account, an API key or a proxy?**
No. The Actor reads the same public data feeds the Flashscore website uses. It goes through Apify's datacenter proxy by default, which is included in every Apify plan.

**How live are live scores?**
Each run takes a snapshot. Today's and yesterday's lists are read at most about 10 seconds old, and match details are read at the moment of the run. For a running scoreboard, schedule the Actor every minute with only-changed mode, so you pay only for matches that changed.

**How do I get alerts for goals or final results?**
Turn on **Only new or changed matches** and give the run a **Monitor name**. Each run compares the matches with the previous run of the same name; rows carry `changeType` (`new` or `updated`) and `changedFields` (for example `score` or `status`). Connect the dataset to Slack, a webhook or Make.

**Why does a football match show 1-1 when Flashscore shows 1-2 after penalties?**
Flashscore adds one goal for the shoot-out winner. The official result is the level score, so `homeScore` and `awayScore` are 1-1, `score.penalties` has the shoot-out (4-5) and `scoreText` reads `1-1 (pens 4-5)`. Flashscore's display is kept in `score.displayed`.

**Which time zone are days in?**
UTC unless you set **Time zone**, for example `Europe/London`, `America/New_York`, `Asia/Kolkata` or `+05:30`. Days start at your local midnight and every match gets `localStartTime` and `localDate`.

**Can I get older seasons?**
Yes. Paste the league URL of that season, for example `https://www.flashscore.com/football/england/premier-league-2024-2025/`, and set **Max matches per league** to 0 for the whole season.

**Where do I find match IDs?**
In the `matchId` field of any run, or in a match URL after `?mid=`.

**Is it legal to scrape Flashscore?**
Scores, fixtures and statistics are facts that Flashscore shows publicly to every visitor; the Actor needs no login and collects no private data. Player and referee names are public but can be personal data under the GDPR, so use them for a legitimate purpose. Check Flashscore's terms and your local law, especially before you republish the data. This Actor is not affiliated with or endorsed by Flashscore or Livesport.

### Support

Found a problem or need a field or sport? Open an issue on the **Issues** tab. Include the run ID; the SUMMARY record usually shows what happened.

# Actor input Schema

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

Every match of these sports on the selected days: fixtures, live games and results. Leave empty to get only the URLs and match IDs below, or today's football when those are empty too.

## `days` (type: `array`):

Days relative to today in your time zone. Flashscore lists 7 days back and 7 days ahead; for older seasons paste a league URL below.

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

Optional. A date range replaces the Days field, for example 2026-10-30. Must be within 7 days of today.

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

Last day of the range (included).

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

Decides where days begin and end, and the <code>localStartTime</code> field. An IANA name such as <code>Europe/London</code>, <code>America/New_York</code>, <code>Asia/Kolkata</code>, or an offset such as <code>+05:30</code>. Default UTC.

## `urls` (type: `array`):

Match pages, league pages (results, fixtures, standings, or a past season such as <code>.../premier-league-2024-2025/results/</code>) and team pages. League pages return the whole season, not only the 15-day window. Team pages return recent results and every upcoming fixture.

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

Flashscore match IDs (8 characters, the <code>matchId</code> field of earlier runs), for example to add details to matches you already have.

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

Only matches in these states. Leave empty for all.

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

Country (England, Spain, USA) or category (World, Europe, ATP, WTA, Challenger). Matches the whole name or its first words, so <code>Ireland</code> is not Northern Ireland and <code>ATP</code> covers ATP singles and doubles. Case and accents are ignored.

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

Part of the competition name: <code>Champions League</code>, <code>NBA</code>, <code>Wimbledon</code>, or a tennis surface such as <code>clay</code>. Add the country for one exact league: <code>England: Premier League</code> (not the Premier League Cup).

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

Only matches with one of these teams or players, for example <code>Alcaraz</code> or <code>Real Madrid</code>. Whole words count (<code>Man</code> does not match Manchester); put a name in double quotes for an exact match: <code>"Arsenal"</code> skips Arsenal Tula.

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

Only the competitions Flashscore lists as top leagues (Premier League, LaLiga, Champions League, NBA, NHL, ATP and WTA tours, Grand Slams and similar).

## `includeIncidents` (type: `boolean`):

Timeline with minute, player, assist, score after each goal, card reasons and substitutions. Venue, city, attendance and referee are added free when known.

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

Every statistic Flashscore shows, per period: xG, possession, shots, corners, aces, rebounds and more, with numbers parsed.

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

Formations, starting players and substitutes with shirt numbers, ratings, captains, coaches and per-player events. Before kick-off: predicted lineups (football) with age, height and market value.

## `includeMissingPlayers` (type: `boolean`):

Missing and doubtful players with the reason (injury, suspension). Football, basketball and ice hockey.

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

Pre-match odds from every bookmaker Flashscore shows for the chosen country: opening and current price, movement, and the winning selection after the match.

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

Bookmakers differ by country. GB returns about 20.

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

Leave empty for every market the match has.

## `oddsScopes` (type: `array`):

Full time by default. Leave empty for every period (larger rows).

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

Previous meetings of the two sides and each side's last matches with results.

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

How many past matches to keep in each list.

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

Every game with server, winner, breaks and the points in order, with break, set and match points counted.

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

One extra row per competition (type <code>standings</code>) with rank, played, wins, draws, losses, goals, points and form. Charged once per table.

## `includeMarkdown` (type: `boolean`):

A readable summary of each match in the <code>markdown</code> field, ready for ChatGPT, Claude, RAG pipelines or a chat bot.

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

Stop after this many matches. 0 or empty = no limit (your spending limit still applies). A full football day can have 1,500 matches.

## `maxMatchesPerLeague` (type: `integer`):

Results and fixtures per league page, newest results first. 0 = the whole season.

## `onlyChanged` (type: `boolean`):

Skip matches whose score, status, period and start time are the same as in the previous run with the same monitor name. Skipped matches are free. Rows get <code>changeType</code> and <code>changedFields</code>.

## `monitorName` (type: `string`):

Any name, for example <code>premier-league-live</code>. Each name keeps its own memory in your account (key-value store <code>flashscore-scraper-monitors</code>).

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

Apify datacenter proxy by default: every retry comes from a new IP address.

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

How many match-detail requests run at the same time.

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

A failed request is retried with a new IP address up to this many times.

## Actor input object example

```json
{
  "days": [
    "0"
  ],
  "timezone": "UTC",
  "topLeaguesOnly": false,
  "includeIncidents": false,
  "includeStatistics": false,
  "includeLineups": false,
  "includeMissingPlayers": false,
  "includeOdds": false,
  "oddsCountry": "GB",
  "oddsScopes": [
    "FULL_TIME"
  ],
  "includeH2H": false,
  "h2hLimit": 10,
  "includePointByPoint": false,
  "includeStandings": false,
  "includeMarkdown": false,
  "maxItems": 30,
  "maxMatchesPerLeague": 200,
  "onlyChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRetries": 5
}
```

# Actor output Schema

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

Delivered matches. Failed sources and filtered matches are not in the dataset and are not charged.

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

Per-source status, matches found and delivered, matches left out by each filter, detail sections and errors.

# 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 = {
    "days": [
        "0"
    ],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("panix/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 = {
    "days": ["0"],
    "maxItems": 30,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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