# Football Fixtures API: Scores, Results and League Table (`conserving_celerytop/open-football-fixtures-api`) Actor

Football fixtures, scores and results per league and season as one row per match, plus a computed league table and last 5 results per team. Public domain openfootball data, no login. $1.00 per 1,000 matches.

- **URL**: https://apify.com/conserving_celerytop/open-football-fixtures-api.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Get football fixtures, scores and results by league and season as one row per match, for $1.00 per 1,000 matches.

Add the leagues and seasons you need, filter by status, dates or team, and get the round, date, kickoff time, home and away team, full time score, half time score and status. The Actor also computes the league table and the last 5 results per team from the same file, at no extra charge. The data comes from the public domain openfootball project. You need no login and no API key.

### Sample output

One row per match. These are real rows from the 2026-27 Premier League, newest first, read on 6 October 2026:

| Date | Round | Home | Score | Away | Status |
|---|---|---|---|---|---|
| 2026-09-20 | Matchday 5 | Fulham FC | 1-1 | Manchester United FC | finished |
| 2026-09-20 | Matchday 5 | Manchester City FC | 5-3 | Sunderland AFC | finished |
| 2026-09-20 | Matchday 5 | Leeds United FC | 0-0 | Crystal Palace FC | finished |
| 2026-09-20 | Matchday 5 | AFC Bournemouth | 0-1 | Liverpool FC | finished |
| 2026-09-19 | Matchday 5 | Nottingham Forest FC | 0-1 | Coventry City FC | finished |

The first row in full:

```json
{
  "league": "en.1",
  "competition": "English Premier League 2026/27",
  "season": "2026-27",
  "round": "Matchday 5",
  "date": "2026-09-20",
  "time": "16:30",
  "homeTeam": "Fulham FC",
  "awayTeam": "Manchester United FC",
  "status": "finished",
  "homeGoals": 1,
  "awayGoals": 1,
  "result": "D",
  "halfTimeHomeGoals": 0,
  "halfTimeAwayGoals": 0,
  "extraTimeHomeGoals": null,
  "extraTimeAwayGoals": null,
  "penaltiesHomeGoals": null,
  "penaltiesAwayGoals": null,
  "sourceUrl": "https://raw.githubusercontent.com/openfootball/football.json/master/2026-27/en.1.json"
}
```

The league table is saved as the `LEAGUE_TABLE` record in the key-value store of the run. This is the top of the same run, after 5 matchdays:

```json
{ "position": 1, "team": "Manchester City FC", "played": 5, "won": 5, "drawn": 0, "lost": 0, "goalsFor": 13, "goalsAgainst": 5, "goalDifference": 8, "points": 15 }
```

The `FORM` record holds the last 5 results per team, for example `"form": "WWWWL"` for Arsenal, with the date, opponent, venue and score of each match.

### How to get football fixtures and scores

1. Click **Try for free**. No API key or proxy is needed.
2. In **Leagues**, add league codes such as `en.1` (Premier League) or `de.1` (Bundesliga), one per line.
3. In **Seasons**, add seasons such as `2026-27`.
4. Optionally set **Status**, **Date from**, **Date to**, **Teams** and **Max matches**.
5. Click **Start**, open the **Overview** view for the matches, and open **LEAGUE_TABLE** and **FORM** in the key-value store.

You can also call it from your own code with the Apify API, run it on a schedule, or connect it to Make, Zapier or n8n.

### Leagues and seasons

The Actor reads one file per league and season from the openfootball project. These codes had a file on 6 October 2026:

| Code | League | Seasons checked |
|---|---|---|
| en.1, en.2, en.3, en.4 | English Premier League, Championship, League One, League Two | 2025-26 (en.1 and en.2 also 2026-27, en.1 from 2010-11) |
| de.1, de.2 | Bundesliga, 2. Bundesliga | 2025-26 (de.1 also 2026-27 and 2010-11) |
| es.1, es.2 | La Liga, Segunda Division | 2025-26 (es.1 also 2026-27) |
| it.1, it.2 | Serie A, Serie B | 2025-26 (it.1 also 2026-27) |
| fr.1, fr.2 | Ligue 1, Ligue 2 | 2025-26 (fr.1 also 2026-27) |
| nl.1, pt.1 | Eredivisie, Primeira Liga | 2025-26 and 2026-27 |
| tr.1, at.1, be.1, sco.1, gr.1 | Turkey, Austria, Belgium, Scotland, Greece | 2025-26 |
| br.1 | Brasileiro Serie A | 2025 and 2026 (calendar year seasons) |
| ar.1, jp.1, cn.1 | Argentina, Japan, China | 2025 |

This list comes from the codes I tested, so other codes may exist. A league and season without a file returns one free status row.

### What you get

- One row per match with round, date, kickoff time, home team, away team, status and goals.
- Half time goals, and extra time and penalty goals where the file lists them.
- The status `finished`, `scheduled`, `postponed` or `canceled`.
- A computed league table (football standings): played, won, drawn, lost, goals for, goals against, goal difference and points.
- The last 5 results per team as a form string such as `WWDLW`, oldest first, with the form points.
- Filters by status, date range and team name, and a sort order of oldest or newest first.

### Pricing

You pay per match row returned. The price is $1.00 per 1,000 matches, which is $0.001 per match. Apify also charges a start event of $0.00005 per GB of run memory, which is $0.0000125 at the default 256 MB. Apify platform usage is included. The league table and the form are free.

| Example | Matches | Cost |
|---|---|---|
| 20 matches of one league | 20 | $0.02 |
| One Premier League season (380 matches) | 380 | $0.38 |
| Five top leagues, one season each (en.1, de.1, es.1, it.1, fr.1) | 1,752 | $1.75 |

Status rows for a league or season without a file, or for filters that match nothing, are free. Paid plans get lower prices per match as your Apify plan tier goes up.

### Input

```json
{
  "leagues": ["en.1"],
  "seasons": ["2026-27"],
  "status": "finished",
  "dateFrom": "2026-09-01",
  "teams": ["Arsenal"],
  "includeTable": true,
  "sortOrder": "desc",
  "maxMatches": 20
}
```

`leagues` and `seasons` are required. At most 20 league and season files are read per run. `status` is `all`, `finished` or `scheduled`. `teams` keeps a match when the home or away name contains the text. `maxMatches` defaults to 1,000 and you pay for each row returned. Dates use the format `YYYY-MM-DD`. If you set `dateTo`, the table and the form count matches up to that date, so you can get a table as of any day.

### Output fields

| Field | Meaning |
|---|---|
| `league`, `competition`, `season` | The league code, the competition name from the file and the season |
| `round`, `date`, `time` | Round name, match date and the kickoff time as listed in the file (no time zone is given). `time` is null when the file has none |
| `homeTeam`, `awayTeam` | Team names as written in the file |
| `status` | `finished`, `scheduled`, `postponed` or `canceled` on match rows. `not_found`, `source_error` or `no_matching_matches` on free status rows |
| `homeGoals`, `awayGoals`, `result` | Full time goals, and `H`, `D` or `A`. Null until the match is finished |
| `halfTimeHomeGoals`, `halfTimeAwayGoals` | Half time goals when listed |
| `extraTime...`, `penalties...` | Extra time and penalty goals when listed |
| `sourceUrl` | The openfootball file the row came from |

### FAQ

#### Is it legal to use this data?

The data comes from the openfootball project, whose football.json repository states that the data is public domain and free to use. The Actor reads a few small files and sends one request at a time with a pause, to keep the load on GitHub low. Check that your own use follows the laws and terms that apply to you.

#### Does it cover soccer results as well?

Yes. Football and soccer are the same game, and the Actor returns the results of the leagues listed above. Names such as Premier League or Bundesliga appear as the league code and the competition name.

#### Which data is not included?

There are no live scores, no odds and no player statistics. Only team names appear, no player names. Only the leagues that exist in the openfootball repository are available. The files are updated about once a day for the current season, so a result can appear some hours after the match.

#### How is the league table computed?

From finished league matches in the file, with 3 points for a win and 1 for a draw. Teams are ordered by points, goal difference, goals for and then team name. Official rules can differ, for example by head to head. Rounds named Playoffs are left out. The table is a computed view and not an official standing.

#### Why did a league return a not_found row?

The league code or the season has no file. Check the code in the list above and the season format, for example `2026-27`, or `2026` for calendar year leagues such as br.1.

#### What if the data host limits a request?

The Actor retries failed requests up to 3 times with a pause. If the host still refuses, you get a free status row for that file and the other files still return rows.

### Related Actors

- RSS Feed Reader turns RSS and Atom feeds, such as club news feeds, into JSON rows.

### About this Actor

I built this Actor as an independent developer. It is not affiliated with or endorsed by the openfootball project or by any league or club. Data comes from the public domain openfootball football.json files. If this saved you time, a rating helps others find it.

# Actor input Schema

## `leagues` (type: `array`):

Add league codes such as en.1 (Premier League), en.2, de.1, es.1, it.1, fr.1, nl.1 or pt.1. A code that has no file for the season returns a status row that is free.

## `seasons` (type: `array`):

Add seasons such as 2026-27. Leagues that play in one calendar year, such as br.1, use 2026. Leagues times seasons can be at most 20 files.

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

Choose which matches to return. Postponed and canceled matches appear only under All matches.

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

Keep matches played on or after this date. Use the format YYYY-MM-DD.

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

Keep matches played on or before this date. The league table and form are also counted up to this date. Use the format YYYY-MM-DD.

## `teams` (type: `array`):

Add team names to keep only their matches, for example Arsenal. A match is kept when the home or away team name contains the text. The table is not filtered.

## `includeTable` (type: `boolean`):

Save a computed league table (LEAGUE_TABLE) and the last 5 results per team (FORM) in the key-value store. They are free.

## `sortOrder` (type: `string`):

Order the match rows by date and kickoff time.

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

Return at most this many match rows in total. You pay for each match row returned.

## Actor input object example

```json
{
  "leagues": [
    "en.1"
  ],
  "seasons": [
    "2026-27"
  ],
  "status": "all",
  "includeTable": true,
  "sortOrder": "asc",
  "maxMatches": 20
}
```

# Actor output Schema

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

No description

## `leagueTable` (type: `string`):

No description

## `form` (type: `string`):

No description

## `stats` (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 = {
    "leagues": [
        "en.1"
    ],
    "seasons": [
        "2026-27"
    ],
    "includeTable": true,
    "maxMatches": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/open-football-fixtures-api").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 = {
    "leagues": ["en.1"],
    "seasons": ["2026-27"],
    "includeTable": True,
    "maxMatches": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/open-football-fixtures-api").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "leagues": [
    "en.1"
  ],
  "seasons": [
    "2026-27"
  ],
  "includeTable": true,
  "maxMatches": 20
}' |
apify call conserving_celerytop/open-football-fixtures-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/open-football-fixtures-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/E7aSRgDEd0CCMvxfz/builds/BbSZVoIHyL7aIXBD1/openapi.json