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

Scrape Ahrefs public Top-Websites data for any domain: Domain Rating, organic search traffic, traffic value in USD, organic keyword count, linking websites with monthly change, top keyword, top country and organic competitors.

- **URL**: https://apify.com/scrapesage/flashscore-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Other, Agents, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.40 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Flashscore Scraper - Live Scores, Results & Fixtures

Every match, every day, across **10 sports** and **hundreds of countries and competitions** - teams, score, live status, kick-off time, red cards, winner and standings links. One run pulls a whole day's global scoreboard.

**No login. No API key. No browser.** It reads Flashscore's lightweight mobile scoreboard, which server-renders the complete list for a sport in ~120 KB.

### Why this Flashscore scraper?

| | Typical Flashscore scrapers | This actor |
|---|---|---|
| Sports covered | usually **one** (tennis, or football only) | **10** - football, tennis, basketball, ice hockey, handball, volleyball, baseball, American football, rugby union, others |
| Competitions per run | one league | **every** country and competition on the board - 310 in a single football request |
| Live matches | partial | ✅ `live` status flagged separately |
| Historical days | ❌ | ✅ up to **7 days back and 7 forward** |
| Red cards | ❌ | ✅ per side |
| Standings link | ❌ | ✅ per competition |
| Winner + total goals | ❌ | ✅ derived, ready to sort |

**Measured 2026-08-09:** one football request returned **748 matches across 247 competitions**; yesterday's returned **1,384 matches across 310 competitions**.

### Use cases

- **Odds & betting models** - a daily results feed across every league, not just the big five.
- **Sports media** - auto-populate scoreboards and match pages.
- **Fantasy & prediction apps** - fixtures for the week ahead, results as they finish.
- **Research** - build a historical results dataset a week at a time.
- **Live dashboards** - schedule every few minutes and filter to `live`.

### How to use

1. Tick your **Sports** and **Days**.
2. Optionally narrow with **Competitions** (e.g. `Premier League`, `ENGLAND`, `Champions League`) and **Match status**.
3. Hit **Start**, then export JSON, CSV or Excel.

### Input

```json
{
    "sports": ["football", "tennis"],
    "dayOffsets": ["0", "-1"],
    "competitionFilter": ["Premier League", "Champions League"],
    "statusFilter": ["finished"],
    "maxItems": 1000
}
```

- **sports** *(pick-list)* - one lightweight page per sport per day.
- **dayOffsets** *(pick-list)* - `-7` … `+7`, labelled Yesterday / Today / Tomorrow.
- **competitionFilter** - keep only matches whose `COUNTRY: Competition` contains one of these. Case-insensitive, partial match.
- **competitionsFromFile** - bulk-load that filter: paste a list, or give **one link** to a `.txt`/`.csv`, Google Sheet, Drive share or key-value-store record. A file that cannot be read **stops the run with a clear message** rather than silently scraping everything.
- **statusFilter** *(pick-list)* - finished / live / scheduled / postponed / cancelled.
- **outputFields** *(pick-list)* - tick exactly the fields you want; all 20 are listed with plain-English labels and their exact key.
- **maxItems**, **proxyConfiguration**.

**Filters run inside the scrape loop, so you are only charged for rows you keep.**

### Output

```json
{
    "type": "match",
    "matchId": "fo75tGe3",
    "url": "https://www.flashscore.com/match/fo75tGe3/",
    "sport": "football",
    "country": "ARMENIA",
    "competition": "Premier League",
    "standingsUrl": "https://www.flashscore.com/standings/lSrMnn3j/820i0mMr/",
    "homeTeam": "Pyunik Yerevan",
    "awayTeam": "Van",
    "homeScore": 3,
    "awayScore": 0,
    "scoreDisplay": "3-0",
    "status": "finished",
    "startTime": "15:00",
    "date": "today",
    "homeRedCards": 0,
    "awayRedCards": 1,
    "winner": "home",
    "totalGoals": 3,
    "scrapedAt": "2026-08-09T20:25:21.448Z"
}
```

#### What to expect (field coverage)

Measured over 2,421 matches spanning football, tennis, basketball, ice hockey and baseball, today and yesterday:

| Field | Coverage |
|---|---|
| `matchId`, `sport`, `country`, `competition`, `homeTeam`, `awayTeam`, `status`, `startTime`, red cards | 100% |
| `homeScore`, `awayScore`, `winner`, `totalGoals` | ~96% - a scheduled match has no score yet, by definition |
| `standingsUrl` | ~75% - cups, friendlies and knock-out rounds have no league table |

**Scores are absent on scheduled matches, not missing.** `scoreDisplay` always tells you what the board showed.

### Automate & schedule

Pair with Apify **Schedules**: every few minutes filtered to `live` for a real-time board, or once daily for a results archive.

### Use with AI assistants (MCP)

Expose this actor to Claude, ChatGPT or any MCP client via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and ask for scores in plain language.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### Pricing

Pay per event: **$0.0004 per match** - a full 748-match football day costs about **$0.30**. Filtered-out matches are not charged.

### FAQ

**How far back can I go?** Roughly seven days either side of today. Days outside that window return nothing and are reported, not charged.

**Are live scores really live?** They are the score on Flashscore's board at the moment of the run. Schedule the actor to keep a board current.

**Why has a match no score?** It has not kicked off. `status` will be `scheduled` and `scoreDisplay` shows what the board displayed.

**Can I get just one league?** Yes - put its name in **Competitions**. Filtering happens during the scrape, so you only pay for what you keep.

### Need help?

Open an issue on the actor's **Issues** tab - feature requests genuinely do get built.

***

*Not affiliated with, endorsed by, or sponsored by Flashscore or Livesport s.r.o. "Flashscore" is a trademark of its respective owner and is used here only to describe what this tool reads. Scrapes public pages only.*

# Actor input Schema

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

Which sports to scrape. Each sport is one lightweight page carrying every country and competition for that day. <b>Leave empty and the run returns a small free sample.</b>

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

Which days to scrape, relative to today. Flashscore publishes roughly a week either side; days outside that window return nothing and are reported, not charged. <b>Leave empty and the run returns a small free sample.</b>

## `competitionFilter` (type: `array`):

Keep only matches whose <code>COUNTRY: Competition</code> contains one of these, e.g. <code>Premier League</code>, <code>ENGLAND</code>, <code>Champions League</code>. Case-insensitive, matches on part of the name. Leave empty for every competition.

## `competitionsFromFile` (type: `string`):

Bulk-load the competition filter. Either <b>paste the whole list</b> (one per line), or give <b>a single link</b> to a public <code>.txt</code>/<code>.csv</code>, a Google Sheet or Drive share link, or an Apify key-value-store record. Blank lines, <code>#</code> comments, CRLF and a UTF-8 BOM all parse. A file that cannot be read stops the run with a clear message rather than silently scraping everything.

## `statusFilter` (type: `array`):

Keep only matches in these states. Leave empty for all.

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

Pick the fields you want and every record is trimmed to exactly those - handy for lean CSV/Sheets exports. <b>Nothing to memorise:</b> open the dropdown and tick, or start typing (<code>score</code>, <code>team</code>) to filter.

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

Maximum number of matches to output across all sports and days.

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

Proxy settings. Flashscore serves the mobile scoreboard cleanly to Apify datacenter proxies, which are used by default. If you ever see blocks, switch to Residential.

## Actor input object example

```json
{
  "sports": [
    "football"
  ],
  "dayOffsets": [
    "0"
  ],
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped matches as JSON items in the default dataset.

# 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"
    ],
    "dayOffsets": [
        "0"
    ],
    "competitionsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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"],
    "dayOffsets": ["0"],
    "competitionsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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"
  ],
  "dayOffsets": [
    "0"
  ],
  "competitionsFromFile": ""
}' |
apify call scrapesage/flashscore-scraper --silent --output-dataset

```

## MCP server setup

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