# Flashscore Scraper — Live Scores, Results, Fixtures & Odds (`fabrikit/flashscore-scraper`) Actor

Flashscore scraper for 25 sports (football, basketball, hockey, tennis, baseball, cricket, esports...): fixtures 7 days ahead, live scores and results 7 days back with half / quarter / set scores, teams, leagues and optional bookmaker odds.

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

## Pricing

from $0.65 / 1,000 match scrapeds

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

Flashscore Scraper extracts fixtures, live scores and final results from flashscore.com for 25 sports (football, basketball, ice hockey, tennis, baseball, American football, cricket, esports and more), with the score of every half, quarter, period or set and, if you want, the bookmaker odds of each match. One request returns a whole day of a sport, so a few hundred matches arrive in seconds, without a browser or a login.

Need tennis in depth? Our [Tennis Scraper](https://apify.com/fabrikit/tennis-scraper) is the specialised sibling this Actor is built on: it adds ATP / WTA rankings and head-to-head history.

### What you get

For every match:

- **Sport and competition**: sport, country or region, Flashscore category, league / stage name, competition URL and ids.
- **Teams or players**: names, Flashscore ids, team or player page, logo or photo, and the country of each player in individual sports.
- **Time and status**: start time (ISO 8601, UTC, plus Unix seconds), date in your timezone, status (`scheduled`, `live`, `finished`, `postponed`, `cancelled`, `interrupted`) and the exact stage (`1st half`, `Half time`, `3rd quarter`, `After penalties`, `Walkover`...).
- **Score**: current or final score, score after regular time, after extra time / overtime, penalty or shoot-out score, winner (`home`, `away`, `draw`).
- **Score by period**: an array with every half, quarter, period, set or inning, overtime last; tie-break points in tennis, wickets and overs in cricket, goals and behinds in Aussie rules.
- **Extras when the sport has them**: red cards (football), hits and errors (baseball), result sentence (cricket), method and round (boxing), Flashscore notes such as "First leg result: 4-0."
- **Odds add-on** (`includeOdds`): number of bookmakers, average and best price for home / draw / away on the sport's main market, plus one row per bookmaker, market and selection with current and opening price.

Supported sports: football, basketball, ice hockey, tennis, American football, baseball, handball, volleyball, cricket, esports, rugby union, rugby league, Aussie rules, futsal, floorball, bandy, darts, snooker, boxing, MMA, table tennis, badminton, water polo, field hockey and netball. Racing, golf, cycling and winter sports are not included.

### Use cases

- **Results databases and dashboards**: pull yesterday's results every morning for the leagues you follow.
- **Fixture calendars**: list the next 7 days of matches for a club, a league or a whole sport.
- **Live score widgets**: schedule short runs during match days and read status, stage and score.
- **Betting and trading models**: collect opening vs. current prices from up to 20 UK bookmakers (or US, German, French, Australian books) next to the final score.
- **Content and newsletters**: generate match previews and recaps from structured data.
- **AI agents**: give an LLM a clean JSON list of today's matches instead of a web page.

### How to use

1. Pick one or more **sports** and the **days** you need (`today`, `yesterday`, `tomorrow`, a date such as `2026-10-24`, or an offset such as `-3`). Flashscore keeps 7 days back and 7 days ahead.
2. Optionally narrow by **status**, **countries**, **leagues** or **teams** (case-insensitive text).
3. Turn on **includeOdds** if you want bookmaker prices and choose the region.
4. Set **maxItems** (and **maxPerSportDay** when you mix sports) and run.

Example input: results of the big European football leagues and the NBA from yesterday, New York time, with UK odds.

```json
{
    "sports": ["football", "basketball"],
    "days": ["yesterday"],
    "statuses": ["finished"],
    "leagues": ["Premier League", "LaLiga", "Serie A", "Bundesliga", "NBA"],
    "timezoneOffset": -5,
    "includeOdds": true,
    "oddsRegion": "gb",
    "oddsMarkets": ["1x2", "home-away", "over-under"],
    "maxItems": 200
}
```

### Output example

A real record (NHL, decided in a shoot-out):

```json
{
    "sport": "hockey",
    "sportName": "Ice hockey",
    "id": "M5bGJxSs",
    "url": "https://www.flashscore.com/match/M5bGJxSs/",
    "date": "2026-10-21",
    "startTime": "2026-10-21T01:40:00.000Z",
    "endTime": "2026-10-21T04:34:33.000Z",
    "status": "finished",
    "statusDetail": "After penalties",
    "country": "USA",
    "league": "NHL",
    "tournamentUrl": "https://www.flashscore.com/hockey/usa/nhl/",
    "homeTeam": "Seattle Kraken",
    "homeTeamUrl": "https://www.flashscore.com/team/seattle-kraken/MibYQ5nU/",
    "awayTeam": "Detroit Red Wings",
    "homeScore": 4,
    "awayScore": 3,
    "homeScoreFullTime": 3,
    "awayScoreFullTime": 3,
    "homeScorePenalties": 2,
    "awayScorePenalties": 1,
    "periods": [
        { "period": 1, "home": 1, "away": 0 },
        { "period": 2, "home": 2, "away": 0 },
        { "period": 3, "home": 0, "away": 3 },
        { "period": 4, "home": 0, "away": 0 }
    ],
    "scoreByPeriod": "1-0, 2-0, 0-3, 0-0",
    "winner": "home",
    "winnerName": "Seattle Kraken"
}
```

With `includeOdds` a match also carries (real values for a Champions League fixture, UK region):

```json
{
    "oddsRegion": "gb",
    "oddsMainMarket": "1x2 (full-time)",
    "oddsBookmakers": 20,
    "oddsHomeAvg": 2.36,
    "oddsDrawAvg": 3.74,
    "oddsAwayAvg": 2.72,
    "oddsHomeBest": 2.45,
    "oddsDrawBest": 3.8,
    "oddsAwayBest": 3,
    "odds": [
        { "bookmaker": "BetVictor", "market": "1x2", "period": "full-time", "selection": "home", "line": null, "odds": 2.38, "openingOdds": 2.25, "active": true }
    ]
}
```

Prices are decimal odds. Home / away sports (basketball, tennis, baseball...) use the moneyline, including overtime when bookmakers price it that way, and have no draw.

### Pricing

Pay per event:

| Event | When |
|---|---|
| Match saved (`match-result`) | each match saved |
| Odds add-on (`match-odds`) | only for matches that have odds |

See the Pricing tab for current prices; paid Apify plans get lower rates. Platform usage is minimal because one request covers a whole day of a sport. Your max-charge limit is respected: the run stops (or skips odds) before going over it.

### How it compares

Most Flashscore Actors in the Store cover a single sport, often tennis. This one covers 25 sports in one schema, adds period scores and an optional multi-bookmaker odds comparison. For ATP / WTA rankings and head-to-head use the [Tennis Scraper](https://apify.com/fabrikit/tennis-scraper). It does not extract lineups, match statistics, incidents or past seasons.

### Integrations

Use the dataset through the Apify API (JSON, CSV, Excel), schedule runs in Apify, or connect it to n8n, Make, Zapier, Google Sheets and webhooks. AI agents can call it through the Apify MCP server and read the clean match records directly.

### FAQ

**Is it legal?** The Actor reads public match information that Flashscore shows to every visitor, at a polite pace. Names of athletes are part of public sports results; no private data is collected. Check Flashscore's terms before republishing the data commercially.

**Do I need a proxy?** Usually not. The Actor connects directly and, only if Flashscore blocks, moves by itself to Apify datacenter and then residential proxies.

**How fresh are live scores?** Each run is a snapshot of Flashscore at that moment. Schedule frequent short runs (a few seconds each) for live tracking.

**How far back can I go?** 7 days back and 7 days ahead, as on the site. Older seasons are not available here.

**Which bookmakers?** It depends on `oddsRegion`, as on the site: about 20 in the United Kingdom, 5 to 8 in the USA (New Jersey), Germany and France, 2 in Australia. Some smaller leagues have no odds; those matches are not charged for the add-on.

### Changelog

- **0.1 (2026-10-21)**: first release: 25 sports, 7 days back / 7 ahead, period scores, filters, odds add-on in 5 regions.

### En español

Flashscore Scraper extrae de flashscore.com el calendario, los resultados en vivo y los resultados finales de 25 deportes (fútbol, básquetbol, hockey sobre hielo, tenis, béisbol, fútbol americano, críquet, esports y más), con el marcador de cada tiempo, cuarto, período o set y, si lo pides, las cuotas de las casas de apuestas de cada partido. Elige deportes y días (de 7 días atrás a 7 adelante), filtra por estado, país, liga o equipo y descarga JSON, CSV o Excel. Consulta la pestaña Pricing para ver los precios actuales; los planes de pago de Apify tienen tarifas más bajas. Para tenis en profundidad (rankings ATP / WTA y head-to-head) usa el [Tennis Scraper](https://apify.com/fabrikit/tennis-scraper).

# Actor input Schema

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

One day listing per sport and day is downloaded (football alone lists 300 to 600 matches a day). Head-to-head sports only: racing, golf, cycling and winter sports are not covered.

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

Which days to list: today, yesterday, tomorrow, a date (2026-10-24) or an offset (-3, +2). Flashscore keeps 7 days back (results) and 7 days ahead (fixtures). Day boundaries follow timezoneOffset.

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

Keep only these statuses. Empty = all. Finished = has a result; postponed, cancelled (incl. abandoned) and interrupted matches have their own status.

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

Keep only matches whose country or Flashscore category contains any of these texts (case-insensitive): England, Spain, Europe, World, ATP - Singles, Counter-Strike...

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

Keep only matches whose competition contains any of these texts (case-insensitive): Premier League, LaLiga, Champions League, NBA, NHL, Euroleague... Also matches the competition URL, e.g. /football/england/premier-league/.

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

Keep only matches with any of these texts in a team or player name, as Flashscore writes it (case-insensitive): Arsenal, Real Madrid, Lakers, Djokovic...

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

Fetch the odds comparison of every saved match: average and best price of the sport's main market plus one row per bookmaker and selection. One extra request per match; billed as match-odds only when Flashscore has odds for that match.

## `oddsRegion` (type: `string`):

Bookmakers differ by country, as on the site. United Kingdom lists about 20 bookmakers; the others list 2 to 8.

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

Markets kept in the odds rows. The average / best summary always uses the sport's main market (1x2 or home-away).

## `oddsAllPeriods` (type: `boolean`):

Off = full-time markets only (including overtime where the sport prices it that way). On = also first half, second half, first quarter... where bookmakers offer them.

## `timezoneOffset` (type: `integer`):

UTC offset used for the day boundaries and the date field: 0 = UTC, 1 = Madrid / Paris in winter, -5 = New York in winter, 8 = Singapore. startTime is always UTC.

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

Stop after this many matches in total (exact; duplicates are never charged).

## `maxPerSportDay` (type: `integer`):

Optional cap for each sport-day listing, so several sports share maxItems instead of the first sport filling it. Empty = no cap.

## `feedSign` (type: `string`):

Value of the x-fsign header Flashscore's own pages send with every feed request. Leave empty for the built-in value; change it only if Flashscore rotates it and the run reports blocks.

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

Optional. Flashscore's data hosts usually answer direct connections; if they block, the Actor moves by itself to Apify datacenter and then residential proxies. Set a proxy here only to force one from the first request.

## Actor input object example

```json
{
  "sports": [
    "football",
    "basketball"
  ],
  "days": [
    "today"
  ],
  "includeOdds": false,
  "oddsRegion": "gb",
  "oddsMarkets": [
    "1x2",
    "home-away"
  ],
  "oddsAllPeriods": false,
  "timezoneOffset": 0,
  "maxItems": 30,
  "maxPerSportDay": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Fixtures, live scores and results of the selected sports and days, with bookmaker odds when includeOdds is on

# 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",
        "basketball"
    ],
    "days": [
        "today"
    ],
    "maxItems": 30,
    "maxPerSportDay": 15,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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