# FIFA World Cup 2026 Fixtures Scraper (`automation-lab/fifa-world-cup-2026-data`) Actor

Export all 104 official FIFA World Cup 2026 fixtures, results, teams, groups, stages, venues, scores, and calculated group tables.

- **URL**: https://apify.com/automation-lab/fifa-world-cup-2026-data.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## FIFA World Cup 2026 Fixtures Scraper

Export **FIFA World Cup 2026 fixtures** and results from FIFA's public structured match feed.

The Actor returns the full 104-match tournament schedule with stable match identity, dates, teams, groups, stages, venues, status, scores, penalty scores, winners, and attendance where FIFA supplies it.
It can also calculate group-table snapshots from the official match results in the same run.

Use it for sports publishing, tournament dashboards, match calendars, results archives, and scheduled data pipelines.

### What does this FIFA World Cup 2026 data Actor do?

The Actor requests the exact FIFA competition and season rather than searching a general football feed.
It normalizes the source response into integration-friendly JSON records.

A run can:

- export all 104 matches;
- select match records, standing records, or both;
- filter either side by team name or country code;
- filter Group A through Group L;
- select a stage such as First Stage or Final;
- limit matches to a UTC date range;
- select scheduled, live, or completed matches;
- request English, Spanish, or French localized names;
- cap combined dataset output with `maxItems`;
- produce a calculated points table for each selected group.

No login, browser, or proxy configuration is required.

### Who is it for?

#### Sports publishers

Refresh fixture and score cards without manually copying tournament pages.
Use stable `matchId` values to update existing stories instead of creating duplicates.

#### Data and newsroom teams

Load normalized World Cup records into spreadsheets, databases, BI tools, or editorial systems.
Schedule the Actor around publishing deadlines.

#### App and dashboard developers

Build calendars, group views, venue pages, team schedules, and results archives from consistent JSON.

#### Tournament analysts

Select one team, group, stage, or date window for focused analysis.
Calculated table rows expose played, won, drawn, lost, goals, goal difference, and points.

### Why use this Actor?

- **Exact tournament scope:** the source request is pinned to FIFA competition `17` and season `285023`.
- **Complete fixture feed:** one current source response contains all 104 World Cup 2026 matches.
- **Typed output:** match and standing records use explicit, documented fields.
- **Useful filters:** team, group, stage, date, and status filters apply before output is charged.
- **Stable identity:** FIFA match and team IDs support repeat-run comparisons.
- **Low overhead:** the implementation uses the public JSON feed directly with 256 MB memory.
- **Fail-closed behavior:** unexpected pagination or malformed upstream responses fail rather than silently returning partial data.

### What FIFA World Cup 2026 fields are extracted?

#### Match records

| Field | Meaning |
| --- | --- |
| `recordType` | Always `match` |
| `matchId` | Stable FIFA match identifier |
| `matchNumber` | Tournament match number when supplied |
| `competition` | Localized competition name |
| `season` | Localized season name |
| `stage` | First Stage, knockout round, Final, or another FIFA stage |
| `group` | Group A through Group L for group matches; otherwise `null` |
| `date` | Scheduled UTC date and time |
| `localDate` | FIFA's local match datetime when supplied |
| `status` | `scheduled`, `live`, or `completed` |
| `homeTeam`, `awayTeam` | Localized team names |
| `homeTeamCode`, `awayTeamCode` | Team abbreviations or country codes |
| `homeTeamId`, `awayTeamId` | Stable FIFA team identifiers |
| `homeScore`, `awayScore` | Current or final scores; nullable before scores exist |
| `homePenaltyScore`, `awayPenaltyScore` | Shootout scores when applicable |
| `winnerTeamId` | FIFA winner team ID when supplied |
| `venue`, `city`, `venueCountryCode` | Match location fields |
| `attendance` | Reported attendance when supplied |
| `sourceUrl` | Exact official API route used |
| `retrievedAt` | UTC retrieval timestamp |

#### Standing records

Standing records use `recordType: "standing"` and contain:

- `group`, `position`, `team`, `teamCode`, and `teamId`;
- `played`, `won`, `drawn`, and `lost`;
- `goalsFor`, `goalsAgainst`, and `goalDifference`;
- `points`;
- `calculation: "calculated-from-official-match-results"`;
- source and retrieval timestamps.

These rows are calculated from the selected official score records.
They are convenient table snapshots, not a separate FIFA-published standings endpoint.

### Getting started

1. Open the Actor input page.
2. Leave `dataTypes` as `matches, standings` for a complete export.
3. Optionally add teams, groups, stages, dates, or a status.
4. Keep the low-cost `maxItems` prefill at `20`, or raise it to `200` for the complete tournament and group tables.
5. Click **Start**.
6. Open the **Matches and standings** dataset view.
7. Export JSON, CSV, Excel, XML, or RSS, or consume the dataset with the Apify API.

The low-cost prefilled input runs without credentials:

```json
{
  "dataTypes": ["matches", "standings"],
  "matchStatus": "all",
  "language": "en",
  "maxItems": 20
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `dataTypes` | string array | `matches, standings` | Output one or both supported record types |
| `teams` | string array | empty | Team names or codes such as `Spain`, `Argentina`, `ESP`, or `ARG` |
| `groups` | string array | empty | Group A through Group L |
| `stages` | string array | empty | Exact or partial FIFA stage names |
| `dateFrom` | `YYYY-MM-DD` | unset | Earliest UTC match date |
| `dateTo` | `YYYY-MM-DD` | unset | Latest UTC match date |
| `matchStatus` | string | `all` | `all`, `scheduled`, `live`, or `completed` |
| `language` | string | `en` | `en`, `es`, or `fr`, with English fallback |
| `maxItems` | integer | `20` | Maximum combined output records, from 1 to 500; use 200 for the complete export |

Team matching is case-insensitive and checks names, short names, abbreviations, and country codes.
Multiple team values use OR logic.
Multiple groups and stages also use OR logic.
Different filter families combine with AND logic.

### Example workflows

#### Export every fixture and table row

```json
{
  "dataTypes": ["matches", "standings"],
  "maxItems": 200
}
```

#### Follow Spain through the tournament

```json
{
  "dataTypes": ["matches"],
  "teams": ["Spain"],
  "matchStatus": "all",
  "maxItems": 20
}
```

#### Refresh Group A results and table

```json
{
  "dataTypes": ["matches", "standings"],
  "groups": ["Group A"],
  "maxItems": 20
}
```

#### Export knockout matches in a date window

```json
{
  "dataTypes": ["matches"],
  "dateFrom": "2026-06-28",
  "dateTo": "2026-07-19",
  "stages": ["Final"],
  "maxItems": 100
}
```

### Example output

A match record looks like this:

```json
{
  "recordType": "match",
  "matchId": "400021443",
  "matchNumber": 1,
  "competition": "FIFA World Cup™",
  "season": "FIFA World Cup 26™",
  "stage": "First Stage",
  "group": "Group A",
  "date": "2026-06-11T19:00:00Z",
  "localDate": "2026-06-11T13:00:00Z",
  "status": "completed",
  "homeTeam": "Mexico",
  "homeTeamCode": "MEX",
  "awayTeam": "South Africa",
  "awayTeamCode": "RSA",
  "homeScore": 2,
  "awayScore": 0,
  "venue": "Mexico City Stadium",
  "city": "Mexico City",
  "venueCountryCode": "MEX",
  "attendance": 80824,
  "sourceUrl": "https://api.fifa.com/api/v3/calendar/matches?...",
  "retrievedAt": "2026-08-15T00:00:00.000Z"
}
```

Nullable fields remain `null`; they are not replaced with guessed values.

### How much does it cost to export FIFA World Cup 2026 data?

Pay-per-event pricing has two parts:

- **$0.005 per run** for the `start` event;
- **$0.00238 per output record at the BRONZE tier**, with lower per-record prices at higher tiers.

BRONZE examples use the same active event prices:

- 1 record: one **$0.005 start event** plus 1 × the **$0.00238 item event**;
- 10 records: one **$0.005 start event** plus 10 × the **$0.00238 item event**;
- 25 records: one **$0.005 start event** plus 25 × the **$0.00238 item event**;
- 100 records: one **$0.005 start event** plus 100 × the **$0.00238 item event**;
- the complete 152-record match-and-table export: one **$0.005 start event** plus 152 × the **$0.00238 item event**.

Charges apply only to records actually saved.
Empty filtered results incur only the one-time start event.
Apify plan tier and platform usage may affect the final account total shown by Apify.

### Scheduled refreshes and change tracking

Create an Apify schedule to run hourly, daily, or around match times.
Use `matchId` as the primary key for match upserts and `group + teamId` for table upserts.
Compare these fields between runs:

- `date`, `stage`, or `venue` for schedule changes;
- `status`, scores, penalties, and winner for result changes;
- `played`, goal difference, points, and position for table changes.

The Actor emits current snapshots.
It does not maintain history or send alerts by itself.
Connect a webhook, Make, Zapier, n8n, or your own consumer to implement notifications.

### API usage with cURL

Start a run and wait for dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fifa-world-cup-2026-data/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataTypes":["matches"],"teams":["Spain"],"maxItems":20}'
```

Never commit your Apify token to source control.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fifa-world-cup-2026-data').call({
    dataTypes: ['matches', 'standings'],
    groups: ['Group A'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fifa-world-cup-2026-data').call(run_input={
    'dataTypes': ['matches'],
    'matchStatus': 'completed',
    'maxItems': 104,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fifa-world-cup-2026-data"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fifa-world-cup-2026-data"
    }
  }
}
```

Example prompts:

- “Run the FIFA World Cup 2026 data Actor and return every Spain match.”
- “Refresh Group A results and summarize the calculated table.”
- “Export completed knockout matches as CSV-ready JSON.”

### Integrations

#### Google Sheets and Excel

Download the default dataset as CSV or XLSX, or update a sheet after each scheduled run.
Use `recordType` to split match and standing rows into separate tabs.

#### Databases and warehouses

Upsert matches by `matchId`.
Upsert standing snapshots by `group`, `teamId`, and `retrievedAt`, or overwrite by `group + teamId` when only the latest state matters.

#### Editorial systems

Trigger a webhook when a run succeeds.
Validate score/status changes before automatically publishing reader-facing copy.

#### Dashboards

Filter match rows for calendars and scorecards.
Filter standing rows for group tables.
Retain source and retrieval timestamps for freshness indicators.

### Limits and failure behavior

- The Actor is intentionally limited to the men's FIFA World Cup 2026 competition and season.
- It does not scrape player statistics, lineups, commentary, odds, tickets, or media.
- Data reflects FIFA's public feed at retrieval time.
- Localized text falls back to English when a requested translation is absent.
- `maxItems` applies to the combined output in match-then-standing order.
- A narrow match filter also narrows the matches used for calculated standings.
- Calculated ranking uses points, goal difference, goals scored, then team name; FIFA's full tie-break rules may produce a different order in a complete tie.
- An unexpected paginated or malformed season response causes a non-zero failure instead of partial output.
- The Actor retries transient source failures three times with bounded delays.

### Troubleshooting

#### The dataset is empty

Check team spelling, group, stage, date range, and `matchStatus`.
Try the prefilled input to confirm the source is available, then add one filter at a time.

#### I requested standings but received no table rows

Standing rows require selected group-stage matches with numeric scores.
A team/date/status filter can exclude some or all score records.
Remove those filters or request the complete group.

#### A run failed with a FIFA API error

The Actor already performs bounded retries.
Inspect the run log and retry later if FIFA's public feed was temporarily unavailable.
No proxy setting is needed.

#### The status does not match a page I just viewed

The API and website can update at slightly different times.
Use `retrievedAt` to show freshness and rerun after a short interval.

### Legality

This Actor accesses public tournament data without authentication.
You are responsible for complying with applicable laws, FIFA terms, Apify terms, and the rules of downstream systems.

Do not imply FIFA endorsement.
Do not misuse team, competition, or event branding.
Review data before using it for high-impact betting, financial, safety, or automated editorial decisions.
Store only the fields needed for your legitimate workflow.

### Related Automation Lab Actors

- [SofaScore Live Events & Statistics Scraper](https://apify.com/automation-lab/sofascore-live-events-statistics-scraper) for multi-sport scheduled and live events.
- [ESPN Multi-League Odds Scraper](https://apify.com/automation-lab/espn-multi-league-odds-scraper) for supported ESPN league and odds workflows.
- [Cricbuzz Live Match Scores Scraper](https://apify.com/automation-lab/cricbuzz-live-match-scores-scraper) for cricket fixtures and live scores.

Use this Actor when the buyer job is specifically the official FIFA World Cup 2026 fixture and result feed.

### FAQ

#### Does it return all 104 FIFA World Cup 2026 matches?

Yes, when the source provides the complete current season response and you use no narrowing filters with `maxItems` of at least 104.
Raise `maxItems` from its low-cost default of 20 to 200 to leave room for calculated standing rows.

#### Are the standings official FIFA table records?

No separate table endpoint is claimed.
The rows are transparently calculated from official match scores and marked with the `calculation` field.

#### Can I filter by more than one team?

Yes.
The Actor keeps a match when either side matches any supplied team value.

#### Can I use country codes?

Yes.
Values such as `ESP`, `ARG`, `MEX`, and `USA` are matched case-insensitively.

#### Can it monitor changes?

Schedule repeat runs and compare stable IDs in your destination.
The Actor returns snapshots; webhook notifications and historical diff storage belong in your integration.

#### Does it need a proxy or FIFA account?

No.
It uses an anonymous public FIFA JSON endpoint and does not expose a proxy mode.

#### What happens when a source field is missing?

Nullable fields remain `null`.
Core records missing match identity, date, or team identity are rejected rather than emitted as misleading partial rows.

# Actor input Schema

## `dataTypes` (type: `array`):

Choose match records, calculated group standings, or both.

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

Optional team names or codes, such as Spain, Argentina, ESP, or ARG. A match is kept when either side matches any value.

## `groups` (type: `array`):

Optional group filters. Supported values are Group A through Group L.

## `stages` (type: `array`):

Optional stage names, such as First Stage, Round of 32, Quarter-final, or Final.

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

Keep matches on or after this UTC date in YYYY-MM-DD format.

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

Keep matches on or before this UTC date in YYYY-MM-DD format.

## `matchStatus` (type: `string`):

Keep all, scheduled, live, or completed matches.

## `language` (type: `string`):

Preferred language for localized competition, stage, team, group, and venue names. English is used when the selected translation is unavailable.

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

Maximum combined match and standing records saved. The low-cost default is 20; use 200 to fit the complete tournament plus calculated group tables.

## Actor input object example

```json
{
  "dataTypes": [
    "matches",
    "standings"
  ],
  "teams": [],
  "groups": [],
  "stages": [],
  "matchStatus": "all",
  "language": "en",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open normalized fixture, result, and calculated group-standing records in the overview dataset view.

## `dataset` (type: `string`):

Read the same normalized records through the default dataset API using the overview view.

# 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 = {
    "dataTypes": [
        "matches",
        "standings"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fifa-world-cup-2026-data").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 = {
    "dataTypes": [
        "matches",
        "standings",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fifa-world-cup-2026-data").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 '{
  "dataTypes": [
    "matches",
    "standings"
  ],
  "maxItems": 20
}' |
apify call automation-lab/fifa-world-cup-2026-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fifa-world-cup-2026-data"
        }
    }
}

```

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/ljCxzNfsfgkvJnQuY/builds/DYO6fuhQN7UDJyrgA/openapi.json