# OpenLigaDB Football Matches Scraper (`parseforge/openligadb-football-matches-scraper`) Actor

Pull OpenLigaDB football data: leagues, seasons, matchdays, teams, fixtures, results, goals, goal scorers, locations, and group stages. Covers Bundesliga, 2. Bundesliga, DFB Pokal, Champions League, and more. Export to JSON, CSV, or Excel for sports analytics and fantasy leagues.

- **URL**: https://apify.com/parseforge/openligadb-football-matches-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result items

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚽ OpenLigaDB Football Matches Scraper

> 🚀 **Export the German football archive in seconds.** Pull **Bundesliga, DFB-Pokal, UEFA Champions League, Euros, and World Cup** fixtures, results, goals, and standings. No API key, no login, no manual ETL.

> 🕒 **Last updated:** 2026-05-23 · **📊 19 fields** per record · **⚽ 10+ competitions** · **🌍 German + international football** · **🏆 Matches, leagues, tables**

The **OpenLigaDB Football Matches Scraper** taps the community-maintained openligadb.de dataset and returns clean, structured records covering **match schedules, halftime and full-time scores, goal scorers, attendance, league standings, and competition catalogs**. The project has powered German football apps, fantasy leagues, and analytics dashboards since 2009.

Coverage spans **Bundesliga 1, 2, and 3, DFB-Pokal, UEFA Champions League, UEFA Nations League, UEFA Euros, FIFA World Cup, and historic seasons** going back to the late 2000s. This Actor exports them as CSV, Excel, JSON, or XML in under a minute, with three query modes (matches, leagues, table) running off the same scraper.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Football analytics teams, fantasy football platforms, sports media, betting researchers, club ops, fan apps, sports data scientists | Match data exports, league standings sync, fixture calendars, goal-scorer leaderboards, season retrospectives, ML training sets |

---

### 📋 What the OpenLigaDB Scraper does

Three workflows in a single Actor:

- 📅 **Matches mode.** Full schedule and results for a league + season, including kickoff times, halftime + final scores, goal scorers, penalties, own goals, overtime, attendance, and venue.
- 🏆 **Leagues mode.** Catalog of every competition openligadb covers, with league ID, shortcut, season, and sport.
- 📊 **Table mode.** Live league standings with points, wins, draws, losses, goals for, goals against, and goal difference.

Each match record includes both teams (ID, name, short name, crest), per-minute goals, and metadata like attendance, location, and last update timestamp.

> 💡 **Why it matters:** building your own football pipeline means writing parsers, handling i18n, and refreshing schedules every gameweek. This Actor turns that into a one-click run that drops a ready-to-load dataset into your warehouse.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded match dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>mode</td><td>string</td><td>"matches"</td><td>One of matches, leagues, table.</td></tr>
<tr><td>league</td><td>string</td><td>"bl1"</td><td>Competition shortcut. bl1 = Bundesliga 1, bl2, bl3, dfb, ucl24, em, wm2022, uefanl2425, fem08, ucl1112.</td></tr>
<tr><td>season</td><td>string</td><td>"2024"</td><td>Season starting year. "2024" means the 2024/25 season.</td></tr>
</tbody>
</table>

**Example: full Bundesliga 1 schedule + results for 2024/25.**

```json
{
    "maxItems": 50,
    "mode": "matches",
    "league": "bl1",
    "season": "2024"
}
````

**Example: current Bundesliga 2 league table.**

```json
{
    "maxItems": 18,
    "mode": "table",
    "league": "bl2",
    "season": "2024"
}
```

> ⚠️ **Good to Know:** openligadb is community-edited, so a small number of recent fixtures may have provisional scores or pending kickoff times. For broadcast-grade data, cross-check with the official competition feed before publishing.

***

### 📊 Output

Each record contains up to **19 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `matchId` | integer | `64637` |
| 🏆 `leagueShortcut` | string | `"bl1"` |
| 🏆 `leagueName` | string | `"1. Fußball-Bundesliga 2024/2025"` |
| 📅 `matchDateUtc` | ISO 8601 | `"2024-08-23T18:30:00Z"` |
| 👥 `team1` | object | `{ teamId, teamName, shortName, teamIconUrl }` |
| 👥 `team2` | object | `{ teamId, teamName, shortName, teamIconUrl }` |
| 🥅 `score` | string | null | `"3-2"` |
| 🥅 `scoreHalftime` | string | null | `"1-1"` |
| ✅ `matchFinished` | boolean | `true` |
| ⚽ `goals` | array | `[{ minute, scorer, isPenalty, isOwnGoal }]` |
| 📍 `location` | object | null | `{ locationCity, locationStadium }` |
| 👨‍👩‍👧 `numberOfViewers` | integer | null | `75000` |
| 🏷️ `groupName` | string | null | `"1. Spieltag"` |
| 🆔 `leagueId` | integer | null | `4422` |
| 📅 `leagueSeason` | integer | `2024` |
| 🕒 `lastUpdate` | ISO 8601 | null | `"2024-08-24T07:14:00"` |
| 🏷️ `recordType` | string | `"match"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>⚽ Bundesliga 1 matchday: Bayer Leverkusen vs Borussia Mönchengladbach</strong></summary>

```json
{
    "recordType": "match",
    "matchId": 64637,
    "leagueShortcut": "bl1",
    "leagueName": "1. Fußball-Bundesliga 2024/2025",
    "leagueSeason": 2024,
    "matchDateUtc": "2024-08-23T18:30:00Z",
    "team1": { "teamId": 6, "teamName": "Bayer Leverkusen", "shortName": "Leverkusen", "teamIconUrl": "https://i.imgur.com/abc.png" },
    "team2": { "teamId": 134, "teamName": "Borussia Mönchengladbach", "shortName": "M'gladbach", "teamIconUrl": "https://i.imgur.com/def.png" },
    "score": "3-2",
    "scoreHalftime": "1-1",
    "matchFinished": true,
    "goals": [
        { "minute": 7, "scorer": "Florian Wirtz", "isPenalty": false, "isOwnGoal": false }
    ],
    "location": { "locationCity": "Leverkusen", "locationStadium": "BayArena" },
    "numberOfViewers": 30210,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📊 League table row: Bundesliga standings</strong></summary>

```json
{
    "recordType": "tableRow",
    "leagueShortcut": "bl1",
    "leagueSeason": "2024",
    "teamName": "Bayer Leverkusen",
    "points": 56,
    "matches": 22,
    "won": 17,
    "draw": 5,
    "lost": 0,
    "goals_for": 59,
    "goals_against": 19,
    "goalDiff": 40,
    "teamIconUrl": "https://i.imgur.com/abc.png",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏆 League catalog entry: Champions League</strong></summary>

```json
{
    "recordType": "league",
    "leagueId": 4612,
    "leagueName": "UEFA Champions League 2024/2025",
    "leagueShortcut": "ucl24",
    "leagueSeason": "2024",
    "sportName": "Fußball",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| ⚽ | **Real match data.** Goals, scorers, kickoff times, attendance, halftime scores, and venue per match. |
| 🏆 | **10+ competitions.** Bundesliga 1/2/3, DFB-Pokal, Champions League, Euros, World Cup, Nations League, plus historic seasons. |
| 📊 | **Three modes.** Matches, league catalog, and live standings from a single Actor. |
| ⚡ | **Fast.** 100 matches in under 10 seconds. |
| 🌐 | **Community-trusted source.** openligadb has powered German football apps for over 15 years. |
| 🔁 | **Always fresh.** Every run pulls the latest community-edited data. |
| 🚫 | **No authentication.** Public dataset, no API key, no login. |

> 📊 Football operations, fantasy platforms, and sports media all depend on accurate match metadata. This Actor delivers it in seconds.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ OpenLigaDB Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **10+ competitions, multi-season** | **Live per run** | league, season, mode | ⚡ 2 min |
| Commercial sports data feeds | $500+/month | Global, live | Streaming | Many | 🐢 Days |
| Manual scraping of league sites | Free | Per-site | Manual | Per-site | 🐌 Weeks |
| Legacy CSV exports | Free | Limited | Stale | None | 🕒 Variable |

Pick this Actor when you want German + UEFA football coverage with goal-level detail and zero auth overhead.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the OpenLigaDB Football Matches Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode (matches / table / leagues), pick a league shortcut, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### ⚽ Football Analytics & Scouting

- Goal-scorer leaderboards across seasons
- Halftime vs full-time score deltas for tactical reports
- Attendance trend analysis per club
- Custom xG model inputs from per-minute goal data

</td>
<td width="50%" valign="top">

#### 🎮 Fantasy Football & Apps

- Auto-sync fixtures and results into mobile apps
- Real-time goal updates for fantasy point engines
- League table widgets for fan sites
- Player and team logos via team icon URLs

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Sports Media & Editorial

- Auto-publish match recap data into CMS
- Season-long stats for end-of-year features
- Historic season comparison stories
- Multi-competition coverage for German + UEFA beats

</td>
<td width="50%" valign="top">

#### 📊 Betting Research & Modeling

- Backtest models against historic Bundesliga seasons
- Calibrate odds with halftime + full-time markets
- Track form trends from goal differential
- Compare league tables across seasons

</td>
</tr>
</table>

***

### 🔌 Automating OpenLigaDB Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Refresh the league table every Monday morning, or pull matchday results every Saturday evening.

***

### 🌟 Beyond business use cases

Structured football data feeds research, classrooms, civic projects, and fan creativity.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Match data for sports analytics coursework
- Historical season studies for journalism school
- Reproducible datasets for ML class projects
- Open-data exercises on European football

</td>
<td width="50%">

#### 🎨 Personal and creative

- Fantasy league spreadsheets and trackers
- Personal Bundesliga dashboards
- Goal-of-the-month video research
- Fan blog data tables and infographics

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Youth football outreach programs with regional clubs
- Community fan club newsletters
- Open historical archives of German football
- Cultural studies of regional football traditions

</td>
<td width="50%">

#### 🧪 Experimentation

- Train goal-prediction or upset-detection ML models
- Prototype agent pipelines that summarize gameweeks
- Build a personal "did Leverkusen win?" Slack bot
- Test data warehouse loaders on football schemas

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20OpenLigaDB%20Football%20Matches%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20OpenLigaDB%20Football%20Matches%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20OpenLigaDB%20Football%20Matches%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20OpenLigaDB%20Football%20Matches%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a competition (Bundesliga 1, DFB-Pokal, Champions League, etc.) and a season, choose a mode (matches, leagues, or table), and the Actor returns one record per match, league, or standings row. No browser automation, no captchas.

#### 📏 How accurate is the data?

Match results, kickoff times, and league standings are typically accurate within minutes of the official scoreboard. Goal scorer attributions are community-edited, so a small number of recent fixtures may include provisional values until reviewers confirm.

#### 🔁 How often is the dataset refreshed?

Live during gameweeks. Every run pulls the latest data, so refreshing every 10 minutes during a matchday gives you near-live scores.

#### 🏆 Which competitions are covered?

Bundesliga 1, 2, and 3, DFB-Pokal, UEFA Champions League, UEFA Euros, FIFA World Cup, UEFA Nations League, and historic seasons. Use Leagues mode to pull the full catalog.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval. Pull the league table after every gameweek and pipe it straight into your dashboard.

#### ⚖️ Is this data legal to use?

The openligadb dataset is publicly available and community-maintained. Review the downstream terms of your specific use case, but raw match metadata is generally public domain.

#### 💼 Can I use this data commercially?

Yes for analytical and editorial use. Team crests and logos belong to their respective clubs, so check brand usage rules before redistributing them.

#### 💳 Do I need a paid Apify plan?

No. The free plan handles testing and small runs (10 records). Paid plans lift the cap and unlock scheduling and higher concurrency.

#### 🔁 What happens if a run fails?

Apify retries transient errors automatically. Failed runs preserve partial datasets so no progress is lost. Re-run after fixing input.

#### 🛬 What if I need player stats or rosters?

This Actor returns match-level, league-level, and standings data. For player-level rosters, request a companion scraper via the contact form below.

#### 🆘 What if I need help?

Reach our support team through the Apify platform or the Tally form linked below.

***

### 🔌 Integrate with any app

OpenLigaDB Football Matches Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get matchday alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe match data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh fixtures into your product backend, or alert your fan club Slack on the final whistle.

***

### 🔗 Recommended Actors

- [**🏆 Football-Data.org Competitions Scraper**](https://apify.com/parseforge/football-data-org-competitions-scraper) - Premier League, La Liga, Serie A, and more
- [**🎮 Liquipedia Esports Wiki Scraper**](https://apify.com/parseforge/liquipedia-esports-wiki-scraper) - Tournament + team data across 10 esports
- [**📺 IMDb Scraper**](https://apify.com/parseforge/imdb-scraper) - Movie, TV, and entertainment metadata
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode stadium addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by OpenLigaDB, the Deutsche Fußball Liga, UEFA, FIFA, or any football competition. All trademarks mentioned are the property of their respective owners. Only publicly available open football data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

matches = full schedule and results, leagues = catalog of available competitions, table = current league standings.

## `league` (type: `string`):

Competition shortcut used by matches and table modes; ignored for leagues mode. Run mode=leagues first to discover every available shortcut (thousands exist for amateur and regional competitions). Common: bl1 (Bundesliga 1), bl2 (Bundesliga 2), bl3 (3. Liga), dfb (DFB-Pokal), ucl24 (Champions League 2024/25), em (UEFA Euros), wm2022 (World Cup 2022), uefanl2425 (Nations League).

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

Season starting year, e.g. '2024' for the 2024/25 season.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "matches",
  "league": "bl1",
  "season": "2024"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "mode": "matches",
    "league": "bl1",
    "season": "2024"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openligadb-football-matches-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "mode": "matches",
    "league": "bl1",
    "season": "2024",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openligadb-football-matches-scraper").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 '{
  "maxItems": 10,
  "mode": "matches",
  "league": "bl1",
  "season": "2024"
}' |
apify call parseforge/openligadb-football-matches-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/openligadb-football-matches-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenLigaDB Football Matches Scraper",
        "description": "Pull OpenLigaDB football data: leagues, seasons, matchdays, teams, fixtures, results, goals, goal scorers, locations, and group stages. Covers Bundesliga, 2. Bundesliga, DFB Pokal, Champions League, and more. Export to JSON, CSV, or Excel for sports analytics and fantasy leagues.",
        "version": "1.0",
        "x-build-id": "R36gsjGXRUNzWFvxG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openligadb-football-matches-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openligadb-football-matches-scraper",
                "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/parseforge~openligadb-football-matches-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openligadb-football-matches-scraper",
                "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/parseforge~openligadb-football-matches-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openligadb-football-matches-scraper",
                "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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "matches",
                            "leagues",
                            "table"
                        ],
                        "type": "string",
                        "description": "matches = full schedule and results, leagues = catalog of available competitions, table = current league standings."
                    },
                    "league": {
                        "title": "League Shortcut",
                        "type": "string",
                        "description": "Competition shortcut used by matches and table modes; ignored for leagues mode. Run mode=leagues first to discover every available shortcut (thousands exist for amateur and regional competitions). Common: bl1 (Bundesliga 1), bl2 (Bundesliga 2), bl3 (3. Liga), dfb (DFB-Pokal), ucl24 (Champions League 2024/25), em (UEFA Euros), wm2022 (World Cup 2022), uefanl2425 (Nations League)."
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Season starting year, e.g. '2024' for the 2024/25 season."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
