# Football-Data.org Competitions Scraper (`parseforge/football-data-org-competitions-scraper`) Actor

Collect football competitions, teams, fixtures, results, standings, scorers, and seasons from football-data.org. Covers Premier League, La Liga, Bundesliga, Serie A, Champions League, World Cup. Export to JSON, CSV, or Excel for sports analytics, betting models, and fan dashboards.

- **URL**: https://apify.com/parseforge/football-data-org-competitions-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 $15.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)

## 🏆 Football-Data.org Competitions Scraper

> 🚀 **Export the global football competition catalog in seconds.** Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, plus standings, fixtures, results, teams, and matches. No setup, no manual ETL.

> 🕒 **Last updated:** 2026-05-23 · **📊 14+ fields** per record · **🏆 14 top competitions** · **🌍 Worldwide football** · **⚽ Competitions, standings, matches, teams**

The **Football-Data.org Competitions Scraper** taps the official football-data.org REST feed and returns clean, structured records for **competitions, league standings, full season fixtures, team profiles, and individual matches**. The catalog covers the biggest European leagues, continental cups, and international tournaments.

Coverage spans **Premier League (PL), La Liga (PD), Bundesliga (BL1), Serie A (SA), Ligue 1 (FL1), UEFA Champions League (CL), Europa League (EL), Championship (ELC), European Championship (EC), FIFA World Cup (WC), Eredivisie (DED), Primeira Liga (PPL), Copa Libertadores (CLI), and Brazilian Série A (BSA)**. The competitions catalog itself returns 180+ leagues. Free tier covers competition discovery; supply your own Auth Token to unlock standings, matches, teams, and match endpoints plus higher rate limits.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Football data nerds, sports betting researchers, fan-app builders, fantasy platforms, sports newsrooms, club ops | League catalog sync, standings refresh, fixture calendars, team rosters, match-level analysis, ML training sets |

---

### 📋 What the Football-Data Scraper does

Five workflows in a single Actor:

- 🏆 **Competitions mode.** Catalog of every competition football-data.org covers, with code, name, area, plan, and current season.
- 📊 **Standings mode.** Full league table for a given competition + season, with points, wins, draws, losses, goals for/against, and recent form.
- 📅 **Matches mode.** All fixtures for a season, with kickoff time, status, score, matchday, and team metadata.
- 🛡️ **Team mode.** Full team profile by ID, including squad, coach, venue, club colors, and running competitions.
- 🎯 **Match mode.** Single match drilldown by match ID, including stage, group, venue, status, and full score breakdown.

Every record includes the source competition, area (country), and a `scrapedAt` timestamp so downstream loads can dedupe cleanly.

> 💡 **Why it matters:** managing tokens, rate limits, paginating fixtures, and joining team data across endpoints is tedious. This Actor turns the whole thing into a single run that returns a flat, joinable dataset.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded competitions 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>"competitions"</td><td>One of competitions, standings, matches, team, match.</td></tr>
<tr><td>competitionCode</td><td>string</td><td>"PL"</td><td>14 codes available. PL, PD, BL1, SA, FL1, CL, ELC, EL, EC, WC, DED, PPL, CLI, BSA.</td></tr>
<tr><td>season</td><td>string</td><td><i>auto</i></td><td>Season starting year, e.g. "2024" for 2024/25.</td></tr>
<tr><td>teamId</td><td>string</td><td><i>none</i></td><td>Required for team mode.</td></tr>
<tr><td>matchId</td><td>string</td><td><i>none</i></td><td>Required for match mode.</td></tr>
<tr><td>areas</td><td>string</td><td><i>none</i></td><td>Comma-separated area IDs for competitions filter.</td></tr>
<tr><td>authToken</td><td>string (secret)</td><td><i>none</i></td><td>Personal token for higher rate limits and restricted tiers.</td></tr>
</tbody>
</table>

**Example: catalog of every football competition.**

```json
{
    "maxItems": 50,
    "mode": "competitions"
}
````

**Example: Premier League 2024/25 standings with your token.**

```json
{
    "maxItems": 20,
    "mode": "standings",
    "competitionCode": "PL",
    "season": "2024",
    "authToken": "your-token"
}
```

> ⚠️ **Good to Know:** the competitions catalog and a few public competitions run on the free tier. Standings, matches, team, and match modes for top-tier competitions often require a free personal token from football-data.org. Add it to `authToken` to unlock them.

***

### 📊 Output

Records vary by mode but all share core fields. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema (Competition mode)

| Field | Type | Example |
|---|---|---|
| 🖼️ `emblem` | string | `"https://crests.football-data.org/PL.png"` |
| 🆔 `id` | integer | `2021` |
| 🏆 `name` | string | `"Premier League"` |
| 🔤 `code` | string | `"PL"` |
| 🏷️ `type` | string | `"LEAGUE"` |
| 🌍 `areaName` | string | `"England"` |
| 🏳️ `areaCode` | string | `"ENG"` |
| 💳 `plan` | string | `"TIER_ONE"` |
| 📅 `currentSeasonStart` | date | `"2024-08-16"` |
| 📅 `currentSeasonEnd` | date | `"2025-05-25"` |
| 🔢 `currentMatchday` | integer | `28` |
| 🗂️ `numberOfAvailableSeasons` | integer | `36` |
| 🕒 `lastUpdated` | ISO 8601 | `"2024-08-16T08:23:45Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏆 Competition: Premier League</strong></summary>

```json
{
    "recordType": "competition",
    "emblem": "https://crests.football-data.org/PL.png",
    "id": 2021,
    "name": "Premier League",
    "code": "PL",
    "type": "LEAGUE",
    "areaName": "England",
    "areaCode": "ENG",
    "plan": "TIER_ONE",
    "currentSeasonStart": "2024-08-16",
    "currentSeasonEnd": "2025-05-25",
    "currentMatchday": 28,
    "numberOfAvailableSeasons": 36,
    "lastUpdated": "2024-08-16T08:23:45Z",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📊 Standings row: Liverpool top of the table</strong></summary>

```json
{
    "recordType": "standingsRow",
    "competitionId": 2021,
    "competitionCode": "PL",
    "season": "2024",
    "stage": "REGULAR_SEASON",
    "teamId": 64,
    "teamName": "Liverpool FC",
    "teamShortName": "Liverpool",
    "teamTla": "LIV",
    "teamCrest": "https://crests.football-data.org/64.png",
    "position": 1,
    "playedGames": 28,
    "points": 67,
    "won": 21,
    "draw": 4,
    "lost": 3,
    "goalsFor": 68,
    "goalsAgainst": 27,
    "goalDifference": 41,
    "form": "W,W,D,W,W",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🛡️ Team: Manchester City</strong></summary>

```json
{
    "recordType": "team",
    "emblem": "https://crests.football-data.org/65.png",
    "id": 65,
    "name": "Manchester City FC",
    "teamShortName": "Man City",
    "teamTla": "MCI",
    "areaName": "England",
    "founded": 1880,
    "clubColors": "Sky Blue / White",
    "venue": "Etihad Stadium",
    "website": "https://www.mancity.com",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏆 | **14+ top competitions.** Premier League, La Liga, Serie A, Bundesliga, Ligue 1, Champions League, Europa, Eredivisie, Libertadores, and more. |
| 📊 | **Five modes.** Competitions catalog, standings, season fixtures, team profiles, and single match drill-downs. |
| 🛡️ | **Rich team data.** Squad, coach, venue, club colors, founded year, running competitions per team. |
| ⚡ | **Fast.** 50 competitions in under 15 seconds, full season fixtures in under a minute. |
| 🔓 | **Free tier works.** Competitions catalog runs without any token. Supply yours to unlock the full feed. |
| 🔁 | **Always fresh.** Every run hits the live football-data.org endpoint. |
| 📐 | **Joinable schema.** Every record carries competition code, area, and season for easy SQL joins. |

> 📊 The competition catalog alone unlocks 180+ leagues and cups for fan apps, fantasy platforms, and betting research.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Football-Data Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **14+ top + 180+ catalog** | **Live per run** | competition, season, area, 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 |
| Static CSV exports | Free | Subset, stale | Rarely | None | 🕒 Variable |

Pick this Actor when you want broad European + UEFA + South American football coverage in a flat schema.

***

### 🚀 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 Football-Data.org Competitions Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode and a competition code. Add your `authToken` if you have one.
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">

#### 🏆 Fan Apps & Fantasy

- Auto-sync league tables for fantasy point engines
- Squad and coach data for player cards
- Multi-competition fixtures in one place
- Team crest CDN for app branding

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

#### 📰 Sports Newsrooms

- Auto-publish match recaps with score + matchday
- Standings widgets for league pages
- Cross-league comparison features
- Historic season pulls for retrospectives

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

#### 📊 Betting Research & Modeling

- Backtest models with historic standings + form
- Calibrate odds against recent form strings
- Track home / away splits via match data
- Cross-competition feature engineering for ML

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

#### ⚽ Club Operations & Scouting

- Track opponent form ahead of matchdays
- Sync rival squad data for scouting reports
- Compete-against benchmarks across leagues
- Multi-league talent search with consistent IDs

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

***

### 🔌 Automating Football-Data 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 standings every Monday morning or pull fixtures every Friday afternoon.

***

### 🌟 Beyond business use cases

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

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

#### 🎓 Research and academia

- Cross-league competitive-balance studies
- Academic papers on football economics
- Reproducible datasets for sports analytics MSc
- Open-data exercises on European football

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

#### 🎨 Personal and creative

- Personal league dashboards
- Fantasy spreadsheets and trackers
- Fan podcast research databases
- Football-themed portfolio dataviz projects

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

#### 🤝 Non-profit and civic

- Youth-football organizations linking to top leagues
- Community sports clubs with league trackers
- Historical archives of competition results
- Open journalism on club governance

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

#### 🧪 Experimentation

- Train upset-prediction or xG ML models
- Prototype an agent that picks fantasy lineups
- Build a "where can I watch?" calendar 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%20Football-Data.org%20Competitions%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%20Football-Data.org%20Competitions%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%20Football-Data.org%20Competitions%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%20Football-Data.org%20Competitions%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 mode (competitions, standings, matches, team, match), set a competition code or ID, and the Actor returns flat records you can load straight into any database.

#### 🔑 Do I need a token?

The competitions catalog and a handful of leagues work without any token. Standings, matches, team, and match modes for top-tier competitions usually require a free personal token from football-data.org. Add it to `authToken`.

#### 📏 How accurate is the data?

Match results, standings, and team metadata are typically accurate within minutes of the official source. Squad data refreshes on a slower cadence (days to weeks) depending on the competition tier.

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

Every run pulls the latest data. Schedule it as often as your tier permits.

#### 🏆 Which competitions are covered?

14 codes plus the full 180+ catalog. PL, PD, BL1, SA, FL1, CL, ELC, EL, EC, WC, DED, PPL, CLI, BSA.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval. Hourly during gameweeks, weekly otherwise.

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

Yes. The football-data.org dataset is publicly available under their terms of service. Crests and trademarks belong to their respective clubs.

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

Analytics and editorial use are typically fine. Re-distributing logos and crests requires brand approval.

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

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

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

Apify retries transient errors automatically. Failed runs preserve partial datasets so no progress is lost.

#### 🛬 What if I need player-level stats?

This Actor returns match, team, and league records. For per-player season stats, 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

Football-Data.org Competitions 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 standings 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 standings into your product backend, or alert your fantasy league Slack on the final whistle.

***

### 🔗 Recommended Actors

- [**⚽ OpenLigaDB Football Matches Scraper**](https://apify.com/parseforge/openligadb-football-matches-scraper) - Bundesliga, DFB-Pokal, UEFA matches + goals
- [**🎮 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 football-data.org, the Premier League, La Liga, the Bundesliga, Serie A, UEFA, FIFA, or any football competition. All trademarks mentioned are the property of their respective owners. Only publicly available 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`):

competitions = list of all competitions, standings = league table, matches = season fixtures, team = team profile, match = single match.

## `competitionCode` (type: `string`):

Competition code used for standings and matches modes. PL = Premier League, PD = La Liga, BL1 = Bundesliga, SA = Serie A, FL1 = Ligue 1, CL = Champions League, ELC = Championship, EL = Europa League, EC = European Championship, WC = World Cup.

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

Season starting year, e.g. '2024' for 2024/25. Optional. Used by standings and matches modes.

## `teamId` (type: `string`):

Numeric team ID. Required for team mode. Example: 65 = Manchester City, 81 = Barcelona.

## `matchId` (type: `string`):

Numeric match ID. Required for match mode.

## `areas` (type: `string`):

Comma-separated area IDs to filter competitions mode, e.g. '2072,2081'. Optional.

## `authToken` (type: `string`):

Personal API key for higher rate limits and access to restricted competitions. Optional — runs on the free tier without it.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "competitions",
  "competitionCode": "PL"
}
```

# 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": "competitions",
    "competitionCode": "PL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/football-data-org-competitions-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": "competitions",
    "competitionCode": "PL",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/football-data-org-competitions-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": "competitions",
  "competitionCode": "PL"
}' |
apify call parseforge/football-data-org-competitions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Football-Data.org Competitions Scraper",
        "description": "Collect football competitions, teams, fixtures, results, standings, scorers, and seasons from football-data.org. Covers Premier League, La Liga, Bundesliga, Serie A, Champions League, World Cup. Export to JSON, CSV, or Excel for sports analytics, betting models, and fan dashboards.",
        "version": "1.0",
        "x-build-id": "RAFwFoPoh7qbkrlF9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~football-data-org-competitions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-football-data-org-competitions-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~football-data-org-competitions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-football-data-org-competitions-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~football-data-org-competitions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-football-data-org-competitions-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": [
                            "competitions",
                            "standings",
                            "matches",
                            "team",
                            "match"
                        ],
                        "type": "string",
                        "description": "competitions = list of all competitions, standings = league table, matches = season fixtures, team = team profile, match = single match."
                    },
                    "competitionCode": {
                        "title": "Competition Code",
                        "enum": [
                            "PL",
                            "PD",
                            "BL1",
                            "SA",
                            "FL1",
                            "CL",
                            "ELC",
                            "EL",
                            "EC",
                            "WC",
                            "DED",
                            "PPL",
                            "CLI",
                            "BSA"
                        ],
                        "type": "string",
                        "description": "Competition code used for standings and matches modes. PL = Premier League, PD = La Liga, BL1 = Bundesliga, SA = Serie A, FL1 = Ligue 1, CL = Champions League, ELC = Championship, EL = Europa League, EC = European Championship, WC = World Cup."
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "Season starting year, e.g. '2024' for 2024/25. Optional. Used by standings and matches modes."
                    },
                    "teamId": {
                        "title": "Team ID",
                        "type": "string",
                        "description": "Numeric team ID. Required for team mode. Example: 65 = Manchester City, 81 = Barcelona."
                    },
                    "matchId": {
                        "title": "Match ID",
                        "type": "string",
                        "description": "Numeric match ID. Required for match mode."
                    },
                    "areas": {
                        "title": "Area IDs",
                        "type": "string",
                        "description": "Comma-separated area IDs to filter competitions mode, e.g. '2072,2081'. Optional."
                    },
                    "authToken": {
                        "title": "Auth Token (optional)",
                        "type": "string",
                        "description": "Personal API key for higher rate limits and access to restricted competitions. Optional — runs on the free tier without it."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
