# Flashscore Team Fixtures, Results & Standings (`extractify-labs/flashscore-team-fixtures`) Actor

Extract upcoming team fixtures, past match results, and current league standings from Flashscore team profile URLs. Supports football, basketball, and other sports. Returns all future matches, configurable result history (default 50), and full division tables with W/D/L stats — no proxy required.

- **URL**: https://apify.com/extractify-labs/flashscore-team-fixtures.md
- **Developed by:** [Extractify Labs](https://apify.com/extractify-labs) (community)
- **Categories:** News, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Team Fixtures, Results & Standings

Last updated: 2026-05-04 | Version: 1.0.0 | Status: Active

Extract upcoming team fixtures, past match results, and current league standings from Flashscore team profile URLs. Supports football, basketball, and other sports. Returns all future matches, configurable result history (default 50 per team), and full division tables with W/D/L stats — all in a single actor run.

### Overview

The flashscore-team-fixtures actor accepts one or more [Flashscore](https://www.flashscore.com) team profile URLs and returns three types of structured data per team: all upcoming scheduled fixtures, recent past match results (configurable depth, default 50), and the complete current league standings table for the team's active tournament. All three data sets are extracted in a single run using Flashscore's internal feed API — no authentication key, no proxy subscription, and no browser automation required.

**Who is this for?** Sports analytics platforms that need to track both upcoming schedule and historical performance. Betting and fantasy apps that require opponent standings context for odds modelling. Team websites that want to display fixtures and standings without embedding a third-party widget. Data journalists compiling season-long statistics.

**What makes it different?** Most Flashscore actors return either match results or live scores. This actor is the only one that combines fixtures + past results + standings for any team in one pass, keyed by team profile URL. Each output item includes a `source_team_url` field that links it back to the input URL that generated it, making multi-team runs easy to segment.

### Key Features

- **All upcoming fixtures for a team** — Returns every future scheduled match with no pagination limit. A team in mid-season may have 40+ scheduled fixtures; plan storage accordingly.
- **Past match results with configurable depth** — Retrieve up to 50 most recent results per team (default), set a higher limit, or pass `null` for the full available history.
- **Full league standings — not just one row** — The standings output includes all teams in the division (typically 16–20 rows for football leagues), not only the queried team. Each row carries W/D/L, goals for/against, goal difference, and points.
- **Multiple teams in one run** — Pass any number of team URLs in `startUrls`; each team's data is returned separately with `source_team_url` for tracking.
- **No proxy required** — Flashscore does not block direct requests. You pay only for Apify compute — no residential or datacenter proxy costs.
- **Football and basketball fully tested** — Additional sports (volleyball, tennis, ice hockey, rugby, handball, baseball, and more) are supported automatically; field availability varies by sport.
- **3-in-1 data model** — A single `record_type` field (`"result"`, `"fixture"`, `"standing"`) distinguishes item types, so the dataset can be filtered or split downstream without joining separate runs.

### Use Cases

#### Sports Analytics Platforms

Aggregate match results and standings data from multiple teams to build season-long performance dashboards. Pass 10–20 team URLs in `startUrls`, set `pastResultsLimit` to the number of previous matches you want per team, and use the structured `tournament_name` and `standing_position` fields to group and rank teams programmatically. The actor returns one consistent JSON schema for all three data types, which integrates directly with pandas, BigQuery, or any standard data pipeline.

#### Betting and Fantasy Applications

Pre-populate upcoming fixture lists and recent results for odds calculation and player prop models. Use `includeFixtures: true` with `includeStandings: true` to get both the team's next opponents and their current division rank in a single run. The `source_team_url` field lets you join the fixture and standings data back to the input team without an additional lookup. Set `pastResultsLimit` to a low value (5–10) for fast runs focused on recency.

#### Team and Club Websites

Display the team's upcoming schedule, recent match history, and divisional standings without embedding a third-party widget or subscribing to a sports data API. Run the actor on a schedule (e.g. daily at midnight) and write the output to your CMS or database. The `match_date` field is ISO 8601 UTC, which converts cleanly to any local timezone.

#### Data Journalism and Research

Compile season statistics, compare division standings at a point in time, or track a team's form over the last N matches. Use `pastResultsLimit: null` to fetch the complete available history for a team, then filter by `tournament_name` or `country_name` to isolate specific competitions. Export the dataset as CSV or XLSX directly from the Apify console.

#### Automated Daily Digest

Schedule the actor to run each morning with `pastResultsLimit: 1` and `includeStandings: true` to get yesterday's result and the updated standings table for each tracked team. Combine with [Apify Webhooks](https://docs.apify.com/platform/integrations/webhooks) to push updates to Slack, a Google Sheet, or an email notification pipeline.

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | — (required) | One or more Flashscore **team profile** URLs. Format: `https://www.flashscore.com/team/{slug}/{team-id}/`. Other URL shapes (tournament pages, match pages) are logged as warnings and skipped. |
| `pastResultsLimit` | integer | `50` | Maximum number of past match results to return **per team**. Set to `null` for unlimited (fetches all available results — can be 200+ for established clubs). This is a per-team limit, not a global cap — use `maxItems` for a global cap. Minimum: 1. |
| `includeFixtures` | boolean | `true` | Include upcoming scheduled fixtures in the output. Returns all future matches — no count limit on fixtures. Set to `false` if you only need results and standings. |
| `includeStandings` | boolean | `true` | Include the full current league standings table. Returns all teams in the division (typically 16–20 rows for football), not just the queried team's row. Set to `false` if you only need match data. |
| `maxItems` | integer | `null` | Global cap on total output items across all teams and all record types (fixtures + results + standings rows combined). Item order is non-deterministic (all three feeds are requested concurrently). A low `maxItems` value may cut off some record types entirely. Leave unset for no limit. |
| `proxyConfiguration` | object | `{"useApifyProxy": false}` | Proxy settings. Flashscore does not block direct requests — you do not need a proxy for normal use. Enable only if you are in a region where Flashscore is geo-restricted. |

#### How to find a team URL

1. Go to [flashscore.com](https://www.flashscore.com)
2. Search for the team name
3. Click the team's profile page — the URL will follow the pattern `https://www.flashscore.com/team/{slug}/{team-id}/`

**Example team URLs:**
- Football: `https://www.flashscore.com/team/manchester-united/ppjDR086/`
- Basketball: `https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/`

### Output Schema

The actor returns a flat dataset. Every item has a `record_type` field that identifies which of three data types the item represents.

#### Fixtures and Match Results (`record_type: "result"` or `"fixture"`)

| Field | Type | Example | Notes |
|-------|------|---------|-------|
| `record_type` | string | `"result"` / `"fixture"` | `"result"` for finished matches; `"fixture"` for scheduled future matches |
| `source_team_url` | string | `"https://www.flashscore.com/team/manchester-united/ppjDR086/"` | The input URL that produced this item |
| `match_id` | string | `"zRIM7cR1"` | Flashscore internal match ID |
| `match_url` | string | `"https://www.flashscore.com/match/football/..."` | Full Flashscore match detail URL |
| `match_date` | string (ISO 8601) | `"2026-05-03T14:30:00+00:00"` | UTC timestamp |
| `match_status` | string | `"Finished"` / `"Scheduled"` | Title case: `Finished`, `Scheduled`, `Postponed`, `Cancelled`, `Live` (for in-progress matches) |
| `home_team_name` | string | `"Manchester Utd"` | Full team name |
| `home_team_id` | string | `"ppjDR086"` | Flashscore team ID |
| `home_team_slug` | string | `"manchester-united"` | URL slug |
| `home_team_short_name` | string | `"MNU"` | 3-letter short code |
| `away_team_name` | string | `"Liverpool"` | Full team name |
| `away_team_id` | string | `"lId4TMwf"` | Flashscore team ID |
| `away_team_slug` | string | `"liverpool"` | URL slug |
| `away_team_short_name` | string | `"LIV"` | 3-letter short code |
| `score_home` | integer | `3` | Home team score. **Absent for scheduled fixtures** (field is missing from the item entirely, not null). |
| `score_away` | integer | `2` | Away team score. **Absent for scheduled fixtures**. |
| `tournament_name` | string | `"Premier League"` | Tournament/league name |
| `tournament_id` | string | `"dYlOSQOD"` | Flashscore tournament ID |
| `tournament_url` | string | `"https://www.flashscore.com/football/england/premier-league/"` | Full tournament URL |
| `country_name` | string | `"England"` | Country or category name |
| `round_name` | string | `"Round 32"` | Round name. **Absent for basketball and cup competitions** that do not use round labels. |
| `sport_name` | string | `"football"` | Lowercase sport name |

**Example result item (football):**
```json
{
  "record_type": "result",
  "source_team_url": "https://www.flashscore.com/team/manchester-united/ppjDR086/",
  "match_id": "zRIM7cR1",
  "match_url": "https://www.flashscore.com/match/football/manchester-united-ppjDR086/liverpool-lId4TMwf/?mid=zRIM7cR1",
  "match_date": "2026-05-03T14:30:00+00:00",
  "match_status": "Finished",
  "home_team_name": "Manchester Utd",
  "home_team_id": "ppjDR086",
  "home_team_slug": "manchester-united",
  "home_team_short_name": "MNU",
  "away_team_name": "Liverpool",
  "away_team_id": "lId4TMwf",
  "away_team_slug": "liverpool",
  "away_team_short_name": "LIV",
  "score_home": 3,
  "score_away": 2,
  "tournament_name": "Premier League",
  "tournament_id": "dYlOSQOD",
  "tournament_url": "https://www.flashscore.com/football/england/premier-league/",
  "country_name": "England",
  "round_name": "Round 36",
  "sport_name": "football"
}
````

**Example fixture item (football — note: no score fields):**

```json
{
  "record_type": "fixture",
  "source_team_url": "https://www.flashscore.com/team/manchester-united/ppjDR086/",
  "match_id": "b3BirtSi",
  "match_url": "https://www.flashscore.com/match/football/manchester-united-ppjDR086/chelsea-p6ahwuwJ/?mid=b3BirtSi",
  "match_date": "2026-05-10T15:00:00+00:00",
  "match_status": "Scheduled",
  "home_team_name": "Manchester Utd",
  "home_team_id": "ppjDR086",
  "home_team_slug": "manchester-united",
  "home_team_short_name": "MNU",
  "away_team_name": "Chelsea",
  "away_team_id": "p6ahwuwJ",
  "away_team_slug": "chelsea",
  "away_team_short_name": "CHE",
  "tournament_name": "Premier League",
  "tournament_id": "dYlOSQOD",
  "tournament_url": "https://www.flashscore.com/football/england/premier-league/",
  "country_name": "England",
  "round_name": "Round 37",
  "sport_name": "football"
}
```

#### League Standings (`record_type: "standing"`)

The standings output returns the **full division table** — all teams in the league, not only the queried team's row. Typically 16–20 rows for a football league; varies by sport and competition format.

| Field | Type | Example | Notes |
|-------|------|---------|-------|
| `record_type` | string | `"standing"` | Always `"standing"` |
| `source_team_url` | string | `"https://www.flashscore.com/team/manchester-united/ppjDR086/"` | The input URL that triggered this standings fetch |
| `tournament_name` | string | `"Premier League"` | Tournament/league name |
| `tournament_id` | string | `"dYlOSQOD"` | Flashscore tournament ID |
| `standing_position` | integer | `5` | Current rank (1-based) |
| `team_name` | string | `"Arsenal"` | Full team name |
| `team_id` | string | `"hA1Zm19f"` | Flashscore team ID |
| `team_logo_url` | string | `"https://static.flashscore.com/res/image/data/abc123.png"` | Team logo CDN URL |
| `matches_played` | integer | `35` | Total matches played this season |
| `wins` | integer | `23` | Wins |
| `draws` | integer | `7` | Draws. **Absent for basketball** and sports with no draw result. |
| `losses` | integer | `5` | Losses |
| `goals_for` | integer | `67` | Goals or points scored. Field label varies by sport but the field name is always `goals_for`. |
| `goals_against` | integer | `26` | Goals or points conceded. Always `goals_against` regardless of sport. |
| `goal_difference` | integer | `41` | `goals_for − goals_against`. **Absent for sports that do not publish GD** (some basketball conferences). |
| `points` | integer | `76` | League points. For basketball this may represent wins or a point-based total depending on the competition. |
| `group_name` | string | `"East Conference"` | Division/group/conference label. **Absent for single-group competitions**. |
| `sport_name` | string | `"football"` | Lowercase sport name |

**Example standings item (football):**

```json
{
  "record_type": "standing",
  "source_team_url": "https://www.flashscore.com/team/manchester-united/ppjDR086/",
  "tournament_name": "Premier League",
  "tournament_id": "dYlOSQOD",
  "standing_position": 1,
  "team_name": "Arsenal",
  "team_id": "hA1Zm19f",
  "team_logo_url": "https://static.flashscore.com/res/image/data/Sj1HJGhe-YKtEQi5I.png",
  "matches_played": 35,
  "wins": 23,
  "draws": 7,
  "losses": 5,
  "goals_for": 67,
  "goals_against": 26,
  "goal_difference": 41,
  "points": 76,
  "sport_name": "football"
}
```

**Note on conditional fields in standings:** This example shows a Premier League row (single-group competition), so `group_name` is absent. For competitions with divisions or conferences (e.g. NBA East/West), `group_name` would be present. `draws` is absent for basketball. `goal_difference` is absent for competitions that do not publish it. All absent fields are missing from the item entirely — not null.

### Sports Support

Football and basketball have been fully tested and validated. Additional sports are supported automatically via the same feed structure; the table below documents which fields are present for each confirmed sport.

| Sport | `draws` | `goal_difference` | `round_name` | `group_name` |
|-------|---------|-------------------|--------------|--------------|
| Football | Present | Present | Present (league rounds) | Present (some cup formats) |
| Basketball | Absent | Present or absent | Absent | Present (conferences) |
| Volleyball | Absent | Present | Present | Present |
| Ice Hockey | Absent | Present | Present | Present |
| Tennis | Absent | Absent | Absent | Absent |
| Rugby | Absent | Present | Present | Present |
| Other sports | Varies | Varies | Varies | Varies |

**Note:** For any sport not in this table, test with a sample URL to confirm which fields are populated. The actor omits missing fields from the item entirely rather than returning null — downstream code should handle optional fields gracefully.

### Input → Output Reference

| Input | Result |
|-------|--------|
| 1 team URL, `includeFixtures: true`, `includeStandings: false` | Fixtures only: typically 10–60 items (full team schedule) |
| 1 team URL, `pastResultsLimit: 50`, `includeFixtures: false`, `includeStandings: false` | 50 result items (last 50 matches) |
| 1 team URL, `includeStandings: true`, `includeFixtures: false`, `pastResultsLimit: 1` | 1 result + 16–20 standings rows |
| 3 team URLs, `pastResultsLimit: 10` (all defaults) | ~30 results + ~90+ fixtures + ~60 standings rows |
| Any team URL, `maxItems: 20` | At most 20 items total (order non-deterministic) |

### Code Examples

#### Python — Single team, all fixtures

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("extractify-labs/flashscore-team-fixtures").call(
    run_input={
        "startUrls": ["https://www.flashscore.com/team/manchester-united/ppjDR086/"],
        "includeFixtures": True,
        "includeStandings": False,
        "pastResultsLimit": 1,  ## minimal results, focus on fixtures
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["record_type"] == "fixture":
        print(item["match_date"], item["away_team_name"])
```

#### Python — Multiple teams, results and standings

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("extractify-labs/flashscore-team-fixtures").call(
    run_input={
        "startUrls": [
            "https://www.flashscore.com/team/manchester-united/ppjDR086/",
            "https://www.flashscore.com/team/chelsea/p6ahwuwJ/",
            "https://www.flashscore.com/team/liverpool/pWXhRF2p/",
        ],
        "pastResultsLimit": 10,
        "includeFixtures": False,
        "includeStandings": True,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
results   = [i for i in items if i["record_type"] == "result"]
standings = [i for i in items if i["record_type"] == "standing"]
print(f"Results: {len(results)}, Standings rows: {len(standings)}")
```

#### How to extract Premier League standings

1. Find the URL for any Premier League team. Example: `https://www.flashscore.com/team/manchester-united/ppjDR086/`
2. Open the actor on the [Apify Store](https://apify.com/extractify-labs/flashscore-team-fixtures).
3. Paste the URL into `startUrls`.
4. Set `includeFixtures: false` and `pastResultsLimit: 1` (minimum results, focus on standings).
5. Set `includeStandings: true`.
6. Click **Start** and download the output.
7. Filter items where `record_type == "standing"`.
8. Sort by `standing_position` (1–20) to get the full table.

### Limitations and Known Issues

**Standings scope.** The actor returns standings for the team's primary active tournament only (e.g. Premier League). It does not return cup competition standings (e.g. FA Cup), European standings (e.g. Champions League), or historical season tables. Use [flashscore-football-seasons](https://apify.com/extractify-labs/flashscore-seasons) for historical data.

**Team profile URLs only.** The actor only accepts Flashscore team profile URLs (`/team/{slug}/{id}/`). Tournament pages, match pages, and player pages are skipped with a warning. If all input URLs are invalid, the actor stops with an error.

**Sport-specific field gaps.** Some sports omit certain fields. Basketball results do not include `draws`. Tennis and some cup competitions do not include `round_name`. The actor omits these fields from the item entirely (absent, not null) — your downstream code should handle missing fields gracefully.

**Conditional scores.** Scheduled fixtures do not have scores. The `score_home` and `score_away` fields are absent (not null) from all fixture items.

**`maxItems` tolerance.** The global `maxItems` cap is approximate: Scrapy's async pipeline may allow one additional item beyond the configured limit. If you set `maxItems: 50` you may receive 50 or 51 items. This is a known Scrapy behaviour (tracked in [tech debt issue #2](https://github.com/web-crawling/apify-flashscore-team-fixtures/issues/2)). For strict limits, filter the dataset downstream.

**UTC timestamps.** All `match_date` values are UTC. Convert to your local timezone in post-processing if needed.

**No real-time updates.** This is a point-in-time extraction. Standings and fixture lists reflect Flashscore's data at the moment the actor runs. Schedule the actor on a daily or hourly interval via [Apify Scheduler](https://docs.apify.com/platform/schedules) to keep data fresh.

### FAQ

#### Why are some past results missing?

The actor fetches results in reverse-chronological order (most recent first). If `pastResultsLimit` is set to 50 and the team has played 200+ matches this season, only the 50 most recent are returned. Increase `pastResultsLimit` or set it to `null` for the full available history.

#### Can I scrape multiple teams in one run?

Yes. Pass any number of team URLs in the `startUrls` array. Each team is processed independently, and every output item includes `source_team_url` so you can identify which input URL produced it. There is no built-in limit on the number of teams — use `maxItems` if you need to cap total output across all teams.

#### What is the difference between this actor and flashscore-results?

[flashscore-results](https://apify.com/extractify-labs/flashscore-results) accepts tournament/league page URLs and returns match results for that competition. This actor accepts team profile URLs and returns fixtures, results, and standings for that specific team. If you need all results across a league (not just one team), use flashscore-results instead.

#### Do I need a proxy?

No. Flashscore allows direct requests from most regions without requiring a proxy. Enable the `proxyConfiguration` option only if you are in a region where Flashscore is geo-restricted.

#### Which sports are supported?

Football and basketball are fully tested and guaranteed. Other sports — volleyball, ice hockey, rugby, tennis, handball, baseball, and more — are automatically supported via the same feed structure, but field availability varies (see the Sports Support table above). If you are using a sport other than football or basketball, test with a sample URL to confirm the output meets your needs.

#### Can I get historical standings from previous seasons?

No. This actor returns the current live standings only. For historical season tables and past season data, use [flashscore-football-seasons](https://apify.com/extractify-labs/flashscore-seasons).

### Related Actors

- [Flashscore: Match Listings, Scores & Fixtures](https://apify.com/extractify-labs/flashscore-extractor) — Daily snapshot of matches across all sports and leagues (±7-day window); no team URL required
- [Flashscore Football Seasons](https://apify.com/extractify-labs/flashscore-seasons) — Historical season standings and tournament statistics
- [Google News Scraper](https://apify.com/apify/google-news-scraper) — Pair match data with sports news articles

# Actor input Schema

## `startUrls` (type: `array`):

One or more Flashscore team profile URLs. Accepted format: `https://www.flashscore.com/team/{slug}/{team-id}/` (trailing slash optional). Examples: `https://www.flashscore.com/team/manchester-united/ppjDR086/`, `https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/`. Other URL shapes (tournament, match, player) are logged as warnings and skipped.

## `includeFixtures` (type: `boolean`):

Include upcoming scheduled fixtures in the output. Returns all future scheduled matches — there is no count limit on fixtures. A team in mid-season can have 40+ scheduled fixtures; factor this into storage expectations. Set to false if you only need results and standings.

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

Include the full current league standings table in the output. Returns the entire league table (all teams in the division, typically 16–20 rows for football, varies by sport) — not just the queried team's row. Each standings row includes a source\_team\_url field that links it back to the input URL that triggered the standings fetch. If a team is in multiple active competitions, only the standings for the primary tournament are returned.

## `pastResultsLimit` (type: `integer`):

Maximum number of past match results to return per team. Controls how many pages of results are fetched. Set to null for unlimited (fetches until no more result rows). Note: this is a per-team limit, not a global cap — see maxItems for a global cap.

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

Global cap on total output items across all item types and all teams (fixtures + results + standings rows combined). Item order is non-deterministic (all three feeds are fetched concurrently). A low maxItems value may cut off some record types entirely. To limit only past results use pastResultsLimit instead. Leave empty for no limit.

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

Flashscore does not block direct requests. You do not need to enable a proxy for normal use. Enable only if you are in a region where Flashscore is geo-restricted.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.flashscore.com/team/manchester-united/ppjDR086/",
    "https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/"
  ],
  "includeFixtures": true,
  "includeStandings": true,
  "pastResultsLimit": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.flashscore.com/team/manchester-united/ppjDR086/",
        "https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractify-labs/flashscore-team-fixtures").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 = { "startUrls": [
        "https://www.flashscore.com/team/manchester-united/ppjDR086/",
        "https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("extractify-labs/flashscore-team-fixtures").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.flashscore.com/team/manchester-united/ppjDR086/",
    "https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/"
  ]
}' |
apify call extractify-labs/flashscore-team-fixtures --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=extractify-labs/flashscore-team-fixtures",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flashscore Team Fixtures, Results & Standings",
        "description": "Extract upcoming team fixtures, past match results, and current league standings from Flashscore team profile URLs. Supports football, basketball, and other sports. Returns all future matches, configurable result history (default 50), and full division tables with W/D/L stats — no proxy required.",
        "version": "1.0",
        "x-build-id": "Rr0xHlpK6ed0dp2lG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/extractify-labs~flashscore-team-fixtures/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-extractify-labs-flashscore-team-fixtures",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/extractify-labs~flashscore-team-fixtures/runs": {
            "post": {
                "operationId": "runs-sync-extractify-labs-flashscore-team-fixtures",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/extractify-labs~flashscore-team-fixtures/run-sync": {
            "post": {
                "operationId": "run-sync-extractify-labs-flashscore-team-fixtures",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Team Profile URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more Flashscore team profile URLs. Accepted format: `https://www.flashscore.com/team/{slug}/{team-id}/` (trailing slash optional). Examples: `https://www.flashscore.com/team/manchester-united/ppjDR086/`, `https://www.flashscore.com/team/golden-state-warriors/SxUtXqch/`. Other URL shapes (tournament, match, player) are logged as warnings and skipped.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeFixtures": {
                        "title": "Include Upcoming Fixtures",
                        "type": "boolean",
                        "description": "Include upcoming scheduled fixtures in the output. Returns all future scheduled matches — there is no count limit on fixtures. A team in mid-season can have 40+ scheduled fixtures; factor this into storage expectations. Set to false if you only need results and standings.",
                        "default": true
                    },
                    "includeStandings": {
                        "title": "Include League Standings",
                        "type": "boolean",
                        "description": "Include the full current league standings table in the output. Returns the entire league table (all teams in the division, typically 16–20 rows for football, varies by sport) — not just the queried team's row. Each standings row includes a source_team_url field that links it back to the input URL that triggered the standings fetch. If a team is in multiple active competitions, only the standings for the primary tournament are returned.",
                        "default": true
                    },
                    "pastResultsLimit": {
                        "title": "Past Results Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of past match results to return per team. Controls how many pages of results are fetched. Set to null for unlimited (fetches until no more result rows). Note: this is a per-team limit, not a global cap — see maxItems for a global cap.",
                        "default": 50
                    },
                    "maxItems": {
                        "title": "Global Results Cap",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Global cap on total output items across all item types and all teams (fixtures + results + standings rows combined). Item order is non-deterministic (all three feeds are fetched concurrently). A low maxItems value may cut off some record types entirely. To limit only past results use pastResultsLimit instead. Leave empty for no limit."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Flashscore does not block direct requests. You do not need to enable a proxy for normal use. Enable only if you are in a region where Flashscore is geo-restricted.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```