# Conference League Results & Tables (`trovevault/conference-league-results-tables`) Actor

Extracts UEFA Conference League fixtures, results, scores, clubs, league-phase standings, and knockout matches.

- **URL**: https://apify.com/trovevault/conference-league-results-tables.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 match or standings

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/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

## Conference League Results & Tables

Conference League Results & Tables returns structured UEFA Conference League fixtures, results, scores, clubs, stages, league phase or groups, and calculated standings for supported seasons. It is built for dashboards, spreadsheets, editorial feeds, tournament monitoring, sports-data enrichment, and API workflows that need clean Apify dataset rows instead of manually checking football pages.

Give the actor a supported season, choose all matches or a specific stage, optionally filter by group and team, and decide whether you want match rows, standings rows, or only completed games. The output keeps fixtures/results and calculated tables clear enough for downstream reporting, scheduled updates, and spreadsheet exports.

### Why use this actor

- Retrieve UEFA Conference League match rows in a consistent schema across supported seasons.
- Filter by season, stage, group, team, and completed games only.
- Calculate standings from completed league-phase or group-stage matches when enough source data is available.
- Export clean rows to CSV, Excel, JSON, XML, or API clients.
- Schedule repeat runs while a competition is active and keep a stable dataset shape.
- Append rows into an existing Apify dataset with `datasetId`.
- Add your own workflow identifier with `runId`.

### What data it produces

#### Match rows

| Field | Meaning |
| --- | --- |
| `competitionName` | Competition name, such as UEFA Conference League. |
| `tournamentName` | Season-specific tournament label. |
| `season` | Selected season or edition. |
| `stage` | Normalized stage, such as group, league, or knockout. |
| `round` | Matchday, group, or knockout-round label. |
| `group` | Group label when available. |
| `homeTeam` / `awayTeam` | Teams or clubs in the match. |
| `homeScore` / `awayScore` | Full-time score when available. |
| `status` | Match status, usually scheduled or finished. |
| `winner` | `home`, `away`, `draw`, or null/empty when not settled. |
| `runId` | Optional workflow identifier. |

#### Standings rows

When `includeStandings` is enabled, the actor can return calculated table rows with team, played, wins, draws, losses, goals for, goals against, goal difference, points, group or league label, and position. Standings are calculated only from completed matches with enough score and grouping data.

### Supported seasons

This version supports:

- 2023-24
- 2024-25

The actor supports the seasons listed in the input schema. New seasons should be added only after source files and parser output are validated.

### Use cases

- **Sports dashboards:** feed UEFA Conference League fixtures, results, and tables into internal or public dashboards.
- **Editorial workflows:** export clean match rows for previews, recaps, and live-content planning.
- **Spreadsheet reporting:** keep fixtures and standings in a repeatable CSV or Excel format.
- **Team monitoring:** filter by a club or national team such as Fiorentina.
- **Historical comparison:** compare recent supported seasons using the same output fields.
- **Scheduled tournament tracking:** run the actor daily during active competitions and consume results through the Apify API.

### How to use it

1. Choose a supported `season`.
2. Set `stage` to all, group/league, or knockout depending on the competition.
3. Optionally choose a `group` or enter a `team` filter.
4. Keep `includeMatches` enabled for fixtures and scores.
5. Enable `includeStandings` when you want calculated table rows.
6. Enable `completedOnly` when you need finished results without scheduled fixtures.
7. Set `maxMatches` to control dataset size.

### Input example

```json
{
  "season": "2024-25",
  "stage": "all",
  "group": "all",
  "team": "Fiorentina",
  "includeMatches": true,
  "includeStandings": true,
  "completedOnly": false,
  "maxMatches": 25,
  "runId": "conference-league-results-tables-2024-25-monitor"
}
````

#### Input reference

| Field | Required | Description |
| --- | --- | --- |
| `season` | Yes | Supported season or edition. |
| `stage` | No | All stages, group/league stage, or knockout stage. |
| `group` | No | Optional exact group or league-phase filter when supported. |
| `team` | No | Optional team or club name filter. |
| `includeMatches` | No | Return match rows. |
| `includeStandings` | No | Return calculated standings rows. |
| `completedOnly` | No | Return only finished match rows. |
| `maxMatches` | No | Cap match rows after filters. |
| `datasetId` | No | Existing Apify dataset to append rows into. |
| `runId` | No | Workflow identifier copied into output rows. |

### Output example

```json
{
  "competitionName": "UEFA Conference League",
  "tournamentName": "UEFA Conference League 2024-25",
  "season": "2024-25",
  "stage": "group",
  "round": "Group A",
  "group": "Group A",
  "homeTeam": "Team A",
  "awayTeam": "Team B",
  "homeScore": 2,
  "awayScore": 1,
  "status": "finished",
  "winner": "home",
  "runId": "conference-league-results-tables-2024-25-monitor"
}
```

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~conference-league-results-tables/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "season": "2024-25",
    "stage": "all",
    "group": "all",
    "includeMatches": true,
    "includeStandings": true,
    "completedOnly": false,
    "maxMatches": 25
  }'
```

### Data semantics

Match rows represent fixtures and results from the selected supported source files. Standings are calculated by the actor from completed matches; they are not official tables published by the competition organizer.

For scheduled monitoring, a match can remain `scheduled` until the public source exposes a completed score. `completedOnly` excludes scheduled fixtures from match rows. Standings already use completed matches regardless of this setting.

When appending output into an external `datasetId`, keep `runId` stable if you need to identify a schedule, report, or downstream workflow.

### Limitations

- This actor is not an official live feed from UEFA Conference League or its organizer.
- Recent fixtures, venues, scores, or standings can lag until the public source updates.
- Coverage is limited to supported seasons listed above.
- Player stats, scorers, cards, substitutions, odds, squads, rankings, and minute-by-minute live events are not included.
- Group or league labels may depend on source structure and should be checked before high-stakes publishing.
- Calculated standings should be treated as workflow data, not as official legal or tournament records.

### Troubleshooting

| Problem | What to try |
| --- | --- |
| Fewer rows than expected | Check `season`, `stage`, `group`, `team`, `completedOnly`, and `maxMatches`. |
| Standings are empty | Confirm `includeStandings` is enabled and the selected scope has completed league-phase, group-stage, and knockout matches. |
| Upcoming matches have no scores | That is expected until the source publishes finished results. |
| Team filter returns nothing | Try the full team name used by the source and remove accents or abbreviations. |
| Need a missing season | Open an issue with the season, expected source, and desired output scope. |

### FAQ

**Is this an official UEFA Conference League feed?**\
No. It normalizes public source data for Apify workflows.

**Can I get only completed games?**\
Yes. Set `completedOnly` to true.

**Can I monitor one team?**\
Yes. Use the `team` filter, for example `Fiorentina`.

**Are standings official?**\
No. They are calculated from completed matches in the available source data.

**Can I schedule this actor?**\
Yes. Use Apify schedules and a stable input configuration.

**Can I export to spreadsheets?**\
Yes. Apify datasets export to CSV, Excel, JSON, XML, and HTML.

**Why is a newer season missing?**\
It has not yet been added and validated in the actor's supported season list.

### Related actors

- World Cup Results & Tables for FIFA World Cup fixtures, results, and tables.
- Professional Cycling Results & Classifications for race-result workflows outside football.
- Other TroveVault football results actors for country-specific leagues and competitions.

### Changelog

- 0.1: Initial TroveVault release with supported UEFA Conference League seasons, match filters, completed-only option, calculated standings, `datasetId`, and `runId` support.

### Feedback and support

Open an issue on the actor page with the input JSON, run ID, expected season or team, and a short description of the missing or incorrect row.

# Actor input Schema

## `season` (type: `string`):

Supported Conference League season or edition. New seasons work after the public dataset adds the matching source file and the actor is updated to expose it.

## `stage` (type: `string`):

Tournament stage to return. League phase is used by UEFA club competitions with a single table.

## `group` (type: `string`):

Optional exact group filter such as Group A. Leave blank or all to include every group or league-phase table.

## `team` (type: `string`):

Optional team or club name filter. Match rows include games where either team contains this text.

## `includeMatches` (type: `boolean`):

Whether to return match rows with dates, teams, scores, stage, round, status, and winner.

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

Whether to calculate standings from completed group-stage or league-phase matches.

## `completedOnly` (type: `boolean`):

When enabled, match rows include only games that already have a full-time score. Standings are always calculated from completed matches.

## `maxMatches` (type: `integer`):

Maximum match rows to return after filters. Use a small value for test runs and a larger value for full exports.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append Conference League matches and standings to in addition to this run's default datasets.

## `runId` (type: `string`):

Optional workflow identifier copied into output rows when provided.

## Actor input object example

```json
{
  "season": "2024-25",
  "stage": "all",
  "group": "all",
  "includeMatches": true,
  "includeStandings": true,
  "completedOnly": false,
  "maxMatches": 104
}
```

# Actor output Schema

## `matches` (type: `string`):

No description

## `standings` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/conference-league-results-tables").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/conference-league-results-tables").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 '{}' |
apify call trovevault/conference-league-results-tables --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/conference-league-results-tables",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Conference League Results & Tables",
        "description": "Extracts UEFA Conference League fixtures, results, scores, clubs, league-phase standings, and knockout matches.",
        "version": "0.1",
        "x-build-id": "6Ori3pOfsWi1KYZNL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~conference-league-results-tables/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-conference-league-results-tables",
                "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/trovevault~conference-league-results-tables/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-conference-league-results-tables",
                "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/trovevault~conference-league-results-tables/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-conference-league-results-tables",
                "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": [
                    "season"
                ],
                "properties": {
                    "season": {
                        "title": "Season / Edition",
                        "enum": [
                            "2023-24",
                            "2024-25"
                        ],
                        "type": "string",
                        "description": "Supported Conference League season or edition. New seasons work after the public dataset adds the matching source file and the actor is updated to expose it.",
                        "default": "2024-25"
                    },
                    "stage": {
                        "title": "Stage",
                        "enum": [
                            "all",
                            "group",
                            "league",
                            "knockout"
                        ],
                        "type": "string",
                        "description": "Tournament stage to return. League phase is used by UEFA club competitions with a single table.",
                        "default": "all"
                    },
                    "group": {
                        "title": "Group",
                        "type": "string",
                        "description": "Optional exact group filter such as Group A. Leave blank or all to include every group or league-phase table.",
                        "default": "all"
                    },
                    "team": {
                        "title": "Team Filter (optional)",
                        "type": "string",
                        "description": "Optional team or club name filter. Match rows include games where either team contains this text."
                    },
                    "includeMatches": {
                        "title": "Include Matches",
                        "type": "boolean",
                        "description": "Whether to return match rows with dates, teams, scores, stage, round, status, and winner.",
                        "default": true
                    },
                    "includeStandings": {
                        "title": "Include Standings",
                        "type": "boolean",
                        "description": "Whether to calculate standings from completed group-stage or league-phase matches.",
                        "default": true
                    },
                    "completedOnly": {
                        "title": "Completed Games Only",
                        "type": "boolean",
                        "description": "When enabled, match rows include only games that already have a full-time score. Standings are always calculated from completed matches.",
                        "default": false
                    },
                    "maxMatches": {
                        "title": "Max Matches",
                        "minimum": 1,
                        "maximum": 153,
                        "type": "integer",
                        "description": "Maximum match rows to return after filters. Use a small value for test runs and a larger value for full exports.",
                        "default": 104
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append Conference League matches and standings to in addition to this run's default datasets."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Optional workflow identifier copied into output rows when provided."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
