# Sofascore Live Events Scraper (`parseforge/sofascore-live-scraper`) Actor

Scrapes live or scheduled Sofascore events by sport and date, and searches for players, managers, or teams by name. Returns each match or entity as a flat row with scores, teams, and status.

- **URL**: https://apify.com/parseforge/sofascore-live-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, News, Automation
- **Features:** Limited permissions
- **Stats:** 167 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.40 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Sofascore Live Events Scraper

**Scrape live scores, fixtures, and player data from Sofascore across 14 sports, up to a million matches per run.** Every event returns teams, scores, and status. Search for players, managers, or teams by name. Export to CSV, JSON, Excel, or XML.

**No minimum charge:** you only pay for the results you get.

Sofascore's live data is locked behind interactive widgets and rate-limited pages. This Actor reads the public event feeds and search endpoints directly, returning structured match data for football, basketball, tennis, cricket, and more. Filter by sport, date, or search query, and get every result in one flat schema.

| Who uses it | What they scrape Sofascore for |
|---|---|
| Sports data analysts | Build historical datasets of match results and live scores across multiple leagues. |
| Betting odds compilers | Monitor live match statuses and final scores for settlement and in-play adjustments. |
| Fantasy sports platforms | Pull player and team performance data to update fantasy points and rankings. |
| Sports journalists | Track live fixtures and results for match reports and breaking news. |

### What it does

This Actor collects live or scheduled Sofascore events by sport and date, or searches for players, managers, and teams by name, and returns each result as a flat row.

- ⚽ **14 supported sports:** football, basketball, tennis, ice hockey, baseball, handball, volleyball, snooker, rugby, MMA, cricket, American football, and esports.
- 🔍 **Entity search:** find players, managers, or teams by name and return their Sofascore IDs and basic details.
- 📅 **Date filtering:** pull scheduled fixtures for a specific date or leave empty to scrape live in-progress events.
- 📊 **Event details:** optionally fetch per-event details like tournament name, round, and venue with one extra request.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Sofascore data

**⚽ Monitor live football scores.**

A sports data startup runs the Actor every 60 seconds with sport set to football and no date, collecting live scores and match statuses for all in-progress games to power a real-time dashboard.

**🔍 Find player profiles by name.**

A fantasy sports platform searches for players like 'Haaland' or 'Mbappe' using the player-search mode to retrieve Sofascore IDs, then enriches their internal database with current season stats.

**📅 Pull tomorrow's tennis fixtures.**

A betting odds team sets the sport to tennis and the date to tomorrow's date, scraping all scheduled ATP and WTA matches to prepare pre-match odds models.

**🏏 Collect cricket match results.**

A cricket analytics site runs the Actor daily with sport set to cricket, fetching completed match scores and team data to update their historical results archive.

### Why choose this scraper

|  | What you get |
|---|---|
| **Live scores without an API key** | Read public Sofascore feeds directly, no registration or OAuth required. |
| **Multi-sport coverage** | One scraper for football, basketball, tennis, cricket, rugby, MMA, and eight more sports. |
| **Search by name** | Find any player, manager, or team on Sofascore with a free-text query. |
| **Flexible output** | Export structured match data to CSV, JSON, Excel, or XML for any downstream pipeline. |

### How it compares

This Actor focuses on live events and entity search across 14 sports with a simple mode selector, while competitors offer broader page scraping or multi-language support.

| Feature | ParseForge | SofaScore scraper PRO⚡ | Sofascore Live Events Scraper | SofaScore Scraper | Live Scores & Match Data API |
|---|---|---|---|---|
| Live events by sport and date | Yes, 14 sports supported | Yes | Yes | Yes |
| Player, manager, and team search | Yes, three dedicated search modes | Not listed | Yes | Yes |
| Optional per-event detail fetch | Yes, one extra request per event | Not listed | Not listed | Not listed |
| Multi-language support | Not listed | Yes | Not listed | Not listed |
| Match statistics and lineups | Not listed | Yes | Not listed | Yes |
| Odds and standings data | Not listed | Not listed | Not listed | Yes |

### Configure the run

Drive the Actor by sport, date, and search query, alone or together. Filters run as each event is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "mode": "events",
  "sport": "football",
  "maxItems": 10
}
```

A larger pull:

```json
{
  "mode": "events",
  "sport": "football",
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0335 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $3.35 |
| 1,000 results | $33.50 |
| 10,000 results | $335.00 |

#### Optional extras (from 3 October 2026)

Seven per-match blocks are now available, each one an extra request to Sofascore and each one priced on its own. Switch on only what you need: a block that does not come back is never charged.

| Event | Price | Charged when |
|---|---|---|
| `match-lineups` | $0.01 per match | starting eleven, bench and formation came back |
| `match-shotmap` | $0.01 per match | the shot map came back |
| `match-statistics` | $0.008 per match | possession, shots and expected goals came back |
| `match-odds` | $0.008 per match | the bookmaker markets came back |
| `match-incidents` | $0.006 per match | the goal, card and substitution timeline came back |
| `player-ratings` | $0.006 per match | the Sofascore ratings came back |
| `head-to-head` | $0.003 per match | the record between the two teams came back |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Sofascore Live Events Scraper](https://apify.com/parseforge/sofascore-live-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Sofascore through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/sofascore-live-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your sport and date combination is valid. If you set a date far in the future or past, Sofascore may not have fixtures. Try leaving the date empty to fetch live events, or use a date within the current season.

**Why is the player search returning unexpected results?**

The query field does a free-text search on Sofascore's endpoint. Try using the player's full name or a more specific query. Partial names like 'Ron' may return multiple players across different sports.

**Why are event details missing even with fetchDetails enabled?**

The fetchDetails option makes an extra request per event, but some events may not have full details available on Sofascore, especially far-future fixtures or very old matches. This is a limitation of the source data.

**Why is the Actor timing out?**

If you set maxItems very high with fetchDetails enabled, the extra requests per event can slow down the run. Try increasing the Actor's timeout in the run settings, or reduce maxItems and run more frequently.

**Why am I getting football results when I selected a different sport?**

Make sure the sport field is set correctly. The default is football when the field is left empty. Select your sport explicitly from the dropdown to override the default.

### FAQ

| Question | Answer |
|---|---|
| What sports does this Actor support? | It supports 14 sports: football, basketball, tennis, ice hockey, baseball, handball, volleyball, snooker, rugby, MMA, cricket, American football, and esports. Leave the sport field empty to default to football. |
| Can I scrape live scores and scheduled fixtures? | Yes. Leave the date field empty to fetch live in-progress events, or set a specific date in YYYY-MM-DD format to pull scheduled fixtures for that day. |
| How do I search for a specific player or team? | Set the mode to player-search, manager-search, or team-search, then enter a free-text query like 'Messi', 'Guardiola', or 'Arsenal'. The Actor returns matching entities with their Sofascore IDs. |
| Does this Actor require a Sofascore API key? | No. It reads the public event feeds and search endpoints directly. No login, API key, or registration is needed. |
| What does the fetchDetails option do? | When enabled, the Actor makes one extra request per event to retrieve additional details like tournament name, round, venue, and referee information. |
| How many matches can I scrape in one run? | You can set maxItems up to 1,000,000 matches per run. The Actor stops once it reaches your limit. |
| Can I filter by a specific league or tournament? | The Actor scrapes all events for the selected sport and date. League or tournament filtering is available in the returned data fields after the run completes. |
| What output formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML from the Apify platform, or access it via the API for automated pipelines. |
| Does this Actor handle tennis scores? | Yes. Set the sport to tennis and leave the date empty for live ATP and WTA scores, or set a date for scheduled matches. |
| Can I run this on a schedule? | Yes. Use Apify's scheduler to run the Actor every minute, hour, or day to build a continuous feed of live scores and fixtures. |

### Related sports data actors

Other ParseForge sports data actors:

- [TennisExplorer Match Results Scraper](https://apify.com/parseforge/tennisexplorer-scraper?fpr=vmoqkp): match results by date and tour, with set scores and odds.
- [Tennis Abstract Scraper](https://apify.com/parseforge/tennis-abstract-scraper?fpr=vmoqkp): every match in a player's history, with surface, round, rank, opponent and score.
- [ESPN Sports Data Scraper](https://apify.com/parseforge/espn-sports-scraper?fpr=vmoqkp): scores, standings, rosters and schedules for NFL, NBA, MLB, NHL and soccer.
- [UFCStats Fighter Scraper](https://apify.com/parseforge/ufcstats-scraper?fpr=vmoqkp): UFC fighter profiles and per-bout striking and grappling stats.

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Sofascore. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from Sofascore. 'events' returns live or scheduled matches; the search modes return entities by name.

## `query` (type: `string`):

Free-text query for player-search / manager-search / team-search modes (e.g. 'Messi', 'Guardiola', 'Arsenal').

## `sport` (type: `string`):

Sport to scrape events for. Leave empty to default to football.

## `date` (type: `string`):

Optional date to fetch scheduled events. Leave empty to fetch live events.

## `fetchDetails` (type: `boolean`):

Fetch additional per-event details (extra request per event). Kept for existing runs: it switches on lineups, statistics and the timeline. The individual switches below give finer control.

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

Starting eleven, bench and formation for both teams, with every player. One request per match. Charged only for a match that actually returns it.

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

Possession, shots, expected goals, passes and duels, grouped by period. One request per match. Charged only for a match that actually returns it.

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

Goals, cards and substitutions with the minute each happened. One request per match. Charged only for a match that actually returns it.

## `includeShotmap` (type: `boolean`):

Every shot of the match with its coordinates, player and outcome. One request per match. Charged only for a match that actually returns it.

## `includePlayerRatings` (type: `boolean`):

Sofascore ratings, including the best player of each side. One request per match. Charged only for a match that actually returns it.

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

The bookmaker markets Sofascore publishes for the match. One request per match. Charged only for a match that actually returns it.

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

The historical record between the two teams, and between their managers. One request per match. Charged only for a match that actually returns it.

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

How many matches to collect per run.

## Actor input object example

```json
{
  "mode": "events",
  "query": "",
  "sport": "football",
  "date": "",
  "fetchDetails": false,
  "includeLineups": false,
  "includeStatistics": false,
  "includeIncidents": false,
  "includeShotmap": false,
  "includePlayerRatings": false,
  "includeOdds": false,
  "includeHeadToHead": false,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete 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 = {
    "mode": "events",
    "query": "",
    "sport": "football",
    "date": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sofascore-live-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 = {
    "mode": "events",
    "query": "",
    "sport": "football",
    "date": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sofascore-live-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 '{
  "mode": "events",
  "query": "",
  "sport": "football",
  "date": "",
  "maxItems": 10
}' |
apify call parseforge/sofascore-live-scraper --silent --output-dataset

```

## MCP server setup

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