# Livesport Scores, Fixtures & Results (`scrapermaster/livesport-scores-fixtures-results`) Actor

Scores, fixtures, live matches, standings and match details across 20+ sports from Livesport: football, tennis, basketball, hockey, baseball and more. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapermaster/livesport-scores-fixtures-results.md
- **Developed by:** [Scraper Master](https://apify.com/scrapermaster) (community)
- **Categories:** Sports, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.81 / 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

## Livesport Scores, Fixtures & Results

Turn public Livesport pages into clean, structured sports data: daily fixtures and results, live scores, full match details, league tables and the schedule of any team. It covers 21 sports, including football (soccer), tennis, basketball, ice hockey, baseball, handball, volleyball, rugby union, American football and MMA.

Data comes from Livesport (livesport.com). This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Livesport or its owners.

### Modes

Pick one with the `mode` input. Every mode honors `maxItems`.

| Mode | What you get | Main inputs |
| --- | --- | --- |
| `fixtures` | One row per match for a day or a date range (up to 15 days, from 7 days back to 7 days ahead) | `sport`, `date` or `dateFrom`/`dateTo`, `status`, `countryFilter`, `tournamentFilter` |
| `live` | Matches in play right now, with score and period or minute | `sport`, optional filters |
| `match-detail` | One row per match with nested sections: lineups, statistics, incidents, match info and head-to-head | `matchIds`, `include*` switches |
| `standings` | One row per team in a tournament table | `tournamentUrl`, `standingsType` |
| `team-fixtures` | Upcoming matches and/or past results of a team | `teamUrl`, `teamScope` |

#### Example inputs

Fixtures for a week of tennis, finished matches only:

```json
{ "mode": "fixtures", "sport": "tennis", "dateFrom": "-3", "dateTo": "today", "status": "finished", "maxItems": 200 }
```

Everything live in basketball:

```json
{ "mode": "live", "sport": "basketball", "maxItems": 100 }
```

Match details (id, or a match URL that contains `?mid=`):

```json
{ "mode": "match-detail", "matchIds": ["plkwWY3D"], "includeLineups": true, "includeStatistics": true, "includeIncidents": true, "includeH2H": true, "h2hMatchesPerSection": 10 }
```

A league table (overall, home or away):

```json
{ "mode": "standings", "tournamentUrl": "https://www.livesport.com/en/soccer/germany/bundesliga/", "standingsType": "overall" }
```

Matches of one team:

```json
{ "mode": "team-fixtures", "teamUrl": "https://www.livesport.com/en/team/dortmund/nP1i5US1/", "teamScope": "both", "maxItems": 60 }
```

Dates accept `YYYY-MM-DD`, `today`, `tomorrow`, `yesterday` or an offset such as `+2` and `-3`.

### Output

Each dataset row has a `recordType` field: `match`, `match-detail`, `standing` or `error`. The dataset has table views for each of them.

#### Match rows (fixtures, live, team-fixtures)

| Field | Description |
| --- | --- |
| `matchId` | Livesport match id |
| `sport`, `country`, `tournament`, `tournamentId`, `tournamentUrl` | Competition context (for tennis the "country" is the tour category, for example ATP - SINGLES) |
| `startTime` | Kick-off, ISO 8601 in UTC |
| `status` | `scheduled`, `live`, `finished`, `not-played` (postponed, cancelled, walkover without score) or `other` |
| `statusDetail`, `minute` | Human readable status. For live football, the phase and an approximate minute computed from the phase start time; for other sports the current period |
| `homeTeam`, `awayTeam`, `homeTeamId`, `awayTeamId` | Participants |
| `homeScore`, `awayScore` | Current or final score (sets for tennis, goals for football). `null` if not started |
| `periodScores` | List of `{ period, home, away }` (half-time for football; sets, quarters, periods or innings for other sports) |
| `matchUrl` | Public match page |
| `teamId` | Only in team-fixtures: the team that was requested |

#### Match-detail rows

Each match is one row and one billable item. The sections are nested fields:

| Field | Description |
| --- | --- |
| `matchId`, `sport`, `country`, `tournament`, `round`, `startTime`, `status`, `homeTeam`, `awayTeam`, `homeScore`, `awayScore`, `matchUrl` | Header data |
| `statistics` | List of `{ period, group, name, home, away }` |
| `incidents` | List of `{ period, side, minute, type, player, playerId, reason, score, commentary, related[] }`. `related` holds assists and the player coming on |
| `matchInfo` | Referee, venue, town, attendance and capacity when published |
| `lineups` | `{ home, away }`, each with `formation`, `starters`, `substitutes`, `coaches` (player id, name, number, country, rating, roles, events) |
| `h2h` | List of `{ tab, title, matches[] }`: head-to-head and recent form lists |
| `sectionErrors` | Present only if one section could not be loaded |

A section is `null` or empty when Livesport does not publish it for that match (for example lineups for lower leagues). Not every sport has every section.

#### Standings rows

`table`, `groupType`, `group`, `rank`, `team`, `teamId`, `teamUrl`, `played`, `wins`, `draws` (null for sports without draws), `losses`, `goalsFor`, `goalsAgainst`, `goalDifference`, `points`, `winPercentage` (where published), `form` (most recent result first, W/D/L), `tournamentId`, `stageId`, `sourceUrl`. Leagues with conferences or divisions return one block of rows per grouping.

#### Errors

If a request fails, the run continues and an error row (`recordType: "error"`, with a `message`) is added to the dataset. Error rows are not charged.

### Notes and limitations

- Public data only. No login, no personal data. Requests are rate limited (at most 3 concurrent, 0.4 to 1.2 seconds between requests, retry with backoff on 429/5xx).
- Odds are not included: Livesport serves them from a separate service that is not part of the plain public feed.
- Livesport lists 7 days back and 7 days ahead of today; other dates are skipped with an error row.
- Day lists follow the Livesport daily grouping in UTC; matches close to midnight can be listed on the neighboring day.
- Minute for live football is an estimate (phase start time based). Stoppage-time and pauses are not modelled.
- Status codes for postponed or cancelled games are not documented by the source, so they are reported as `not-played` with the raw code in `statusDetail`.
- Some sports publish fewer details than football (no lineups, or no incidents).
- Team and tournament pages are identified by the ids in Livesport URLs. If Livesport changes its page structure the Actor may need an update.

### Technical notes

The Actor reads the same text feeds the Livesport web client uses (`/x/feed/...` on livesport.com). Those requests carry the `x-fsign` header that the site publishes as a constant in its own public JavaScript. The value is kept in one file, `src/constants.js`, and is re-read from the site's public script if the feed ever answers 401.

Run locally:

```
npm install
sh run-test.sh '{"mode":"fixtures","sport":"soccer","date":"today","maxItems":10}'
```

### Disclaimer

This project is not affiliated with Livesport, Flashscore or their owners. Livesport and related names are trademarks of their respective owners. Make sure your use of the collected data complies with the site's terms and the laws that apply to you.

# Actor input Schema

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

fixtures: matches for a date range. live: matches in play right now. match-detail: lineups, statistics, incidents and head-to-head for specific matches. standings: league table of a tournament. team-fixtures: results and/or upcoming matches of one team.

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

Used by the fixtures and live modes (and by team-fixtures when you give a bare team id instead of a team URL).

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

Single day for the fixtures mode: YYYY-MM-DD, today, tomorrow, yesterday, or an offset such as +2 or -3. Livesport serves 7 days back and 7 days ahead of today. Ignored when Date from is set.

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

Start of a date range (same formats as Date). Leave empty to use the single Date field.

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

End of the date range, inclusive. At most 15 days in total (Livesport only serves -7 to +7 days around today).

## `status` (type: `string`):

Keep all matches, or only live, scheduled or finished ones (fixtures mode).

## `countryFilter` (type: `string`):

Optional text filter on the country or category, for example germany or ATP. Case-insensitive.

## `tournamentFilter` (type: `string`):

Optional text filter on the tournament name, for example bundesliga or champions league. Case-insensitive.

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

Match ids (8 characters, the mid value in a match URL) or full match URLs that contain ?mid=...

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

Match-detail mode: add the lineups section (not every match has one).

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

Match-detail mode: add the match statistics section.

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

Match-detail mode: add goals, cards, substitutions and the match info (referee, venue, attendance).

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

Match-detail mode: add head-to-head and recent-form match lists.

## `h2hMatchesPerSection` (type: `integer`):

How many matches to keep in each head-to-head list of the match-detail mode.

## `tournamentUrl` (type: `string`):

A Livesport tournament URL such as https://www.livesport.com/en/soccer/germany/bundesliga/ , a standings URL, or a pair like KY7LrA6d/jg0MwVuC (tournament id / stage id).

## `standingsType` (type: `string`):

Overall, home-only or away-only table.

## `teamUrl` (type: `string`):

A Livesport team URL such as https://www.livesport.com/en/team/dortmund/nP1i5US1/ or just the 8-character team id (then choose the Sport too).

## `teamScope` (type: `string`):

Upcoming matches, past results, or both.

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

Upper limit of result rows produced (each match, match-detail or standings row counts as one item).

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

Optional. Requests normally work without a proxy.

## Actor input object example

```json
{
  "mode": "fixtures",
  "sport": "soccer",
  "date": "today",
  "status": "all",
  "matchIds": [
    "plkwWY3D"
  ],
  "includeLineups": true,
  "includeStatistics": true,
  "includeIncidents": true,
  "includeH2H": true,
  "h2hMatchesPerSection": 10,
  "tournamentUrl": "https://www.livesport.com/en/soccer/germany/bundesliga/",
  "standingsType": "overall",
  "teamUrl": "https://www.livesport.com/en/team/dortmund/nP1i5US1/",
  "teamScope": "both",
  "maxItems": 50
}
```

# Actor output Schema

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

No description

# 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 = {
    "date": "today",
    "matchIds": [
        "plkwWY3D"
    ],
    "tournamentUrl": "https://www.livesport.com/en/soccer/germany/bundesliga/",
    "teamUrl": "https://www.livesport.com/en/team/dortmund/nP1i5US1/",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapermaster/livesport-scores-fixtures-results").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 = {
    "date": "today",
    "matchIds": ["plkwWY3D"],
    "tournamentUrl": "https://www.livesport.com/en/soccer/germany/bundesliga/",
    "teamUrl": "https://www.livesport.com/en/team/dortmund/nP1i5US1/",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapermaster/livesport-scores-fixtures-results").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 '{
  "date": "today",
  "matchIds": [
    "plkwWY3D"
  ],
  "tournamentUrl": "https://www.livesport.com/en/soccer/germany/bundesliga/",
  "teamUrl": "https://www.livesport.com/en/team/dortmund/nP1i5US1/",
  "maxItems": 50
}' |
apify call scrapermaster/livesport-scores-fixtures-results --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapermaster/livesport-scores-fixtures-results"
        }
    }
}
```

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/mZtjJPFrI9s2TjDQn/builds/chcoQl2SMY9lbD0MA/openapi.json