# FotMob Scraper ⚽ Match Details, Stats, Lineups & Players (`abotapi/fotmob-scraper`) Actor

From $0.8/1K. Pull structured football data from FotMob: match details with scores, team stats, events, lineups, player ratings, H2H, league tables and fixtures, team squads, and player careers. Paste match URLs, pull fixtures by date, or scrape leagues, teams and players.

- **URL**: https://apify.com/abotapi/fotmob-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** News, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 93.5% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result records

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

## FotMob Scraper: Match Details, Stats, Lineups & Players

FotMob Scraper turns FotMob into a clean football data API. Get full match details with scores, team stats, goals and cards, lineups with player ratings, shot-by-shot shotmaps with xG, head-to-head history, league tables and fixtures, team squads and player career histories. Paste match links, pull every fixture on a date, or scrape whole leagues, teams and players, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Seven ways to find data.** Matches by id, pasted FotMob links, fixtures on any date, whole leagues, teams, players, or the latest news. No need to build URLs by hand.
- **Full match depth, rival-beating.** Every match record carries scores, team stats, events, lineups, flat player-stat rows, shotmaps, team form and player of the match - a superset of the best-known match-details scraper on the store.
- **League, team, player and news surfaces.** League tables with fixtures and seasons, team squads with form, player careers with trophies and recent matches, plus the latest football news articles - surfaces a match-only scraper cannot reach.
- **Shot-level xG.** The shotmap records every shot's coordinates, shooter, body part, situation and expected goals.
- **Built for schedules.** Incremental mode returns only new and changed records on recurring runs, and a refused run fails loudly instead of returning an empty dataset.
- **Simple per-result pricing.** Every record bills the same tiered rate (lower per plan tier) — plus a small surcharge only for news articles whose full text was read.

### Use Cases

- **Who:** sports betting and odds researchers - collect team stats, xG shotmaps, head-to-head records and form to build and backtest models.
- **Who:** live score apps and dashboards - feed fixtures, scores, events and ratings into your own site, bot or alerting tool.
- **Who:** fantasy sports and scouting teams - track player ratings, positions, squads and career moves across leagues.
- **Who:** sports analytics and data science teams - build historical datasets of results, xG-bearing stats and lineups for machine learning.
- **Who:** media and content teams - generate match previews, reports and league tables automatically.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `type` | `"match"` (also `"league"`, `"team"`, `"player"`, `"news"`) |
| `matchId` / `id` | `4506324` |
| `matchName` | `"Aston Villa-vs-Manchester United_Sun, Oct 6, 2024, 13:00 UTC"` |
| `matchUrl` | FotMob link to the match |
| `leagueId` / `leagueName` | `47` / `"Premier League"` |
| `round` / `roundName` | `"7"` / `"7"` |
| `countryCode` | `"ENG"` |
| `matchTimeUtc` | `"2024-10-06T13:00:00.000Z"` |
| `started` / `finished` | `true` / `true` |
| `homeTeam` / `awayTeam` | `{"id": 10252, "name": "Aston Villa", "score": 0}` |
| `venue` | name, city, country, capacity, surface |
| `referee` / `attendance` | `"Referee Name"` / `42682` |
| `playerOfTheMatch` | `{"playerId": 268375, "name": "Emiliano Martinez", "teamName": "Aston Villa"}` |
| `teamStats[]` | `{group, title, key, home, away}` - possession, xG, shots |
| `events[]` | `{type, minute, minuteLabel, isHome, playerId, playerName, homeScore, awayScore, card, goalType, assist, playersInvolved}` |
| `lineups` | `{home, away: {teamId, teamName, formation, coach, starters[], subs[]}}` |
| `playerStats[]` | flat per-player rows with ratings, minutes, goals, saves, xG |
| `shotmap` | every shot: coordinates, shooter, shotType, situation, expectedGoals |
| `momentum` | minute-by-minute win-probability swing for the match |
| `attackingZones` | left/center/right attack split per half for both sides |
| `h2h` | past meetings between the two teams (when enabled) |
| `leagueTable` / `fixtures` | league records: full table, all fixtures, seasons |
| `transfers` | league records: latest transfer rows |
| `squad` | team records: players grouped by role (coach, keepers, defenders, midfielders, attackers) |
| `lastMatch` / `nextMatch` | team records: previous and upcoming fixture |
| `history` | team records: trophy list with seasons won |
| `careerHistory` / `trophies` / `recentMatches` | player records |
| `statSeasons` / `mainLeague` | player records: per-season tournaments and current-season headline stats |
| `marketValues` / `traits` | player records: transfer-value history and stat traits vs peers |
| `bodyText` / `bodyHtml` / `lead` | news records: full article text (FotMob-native articles) |
| `source` / `scrapedAt` | `"fotmob"` / run timestamp |

League records also carry seasons, stats and overview; team records carry form, fixtures and transfers; player records carry position, team, birth date and detailed information; news records carry title, lead, source, image and publish time (and the full article body when enabled).

### How to Use

1. Pick a **mode**: `matches` (by id), `urls` (paste links), `fixturesByDate` (all matches on a date), `league`, `team`, `player`, or `news` (latest articles).
2. Fill in the fields for that mode, and switch on the match details you need.
3. Set **Max items** to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Latest football news (the default — at least 20 results out of the box):**

```json
{
 "mode": "news",
 "newsPages": 2,
 "maxItems": 20
}
```

**One match by id:**

```json
{
 "mode": "matches",
 "matchIds": ["4506324"],
 "maxItems": 1
}
```

**Every Premier League fixture on a date:**

```json
{
 "mode": "fixturesByDate",
 "date": "2026-08-29",
 "daysAhead": 0,
  "leagueIds": ["47"],
  "maxItems": 20
}
```

**Paste links (match, team, player, league):**

```json
{
 "mode": "urls",
 "urls": [
  "https://www.fotmob.com/match/4506324",
  "https://www.fotmob.com/teams/10252/overview/aston-villa",
  "https://www.fotmob.com/players/268375/emiliano-martinez",
  "https://www.fotmob.com/leagues/47/overview/premier-league"
 ]
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/fotmob-scraper").call(run_input={"mode": "matches", "matchIds": ["4506324"]})
for match in client.dataset(run["defaultDatasetId"]).iterate_items():
 print(match["matchName"], match["homeTeam"], match["awayTeam"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/fotmob-scraper').call({ mode: 'matches', matchIds: ['4506324'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run or dataset ID and the actor skips everything already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same scope. Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only after a run that scanned the whole scope, and only with `emitExpired`). `stateKey` names or shares the stored state. With incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `news` | `news`, `matches`, `urls`, `fixturesByDate`, `league`, `team`, or `player`. |
| `matchIds` | array | `["4506324"]` | Match ids or match URLs (matches mode). |
| `urls` | array | sample | FotMob match/team/player/league links (url mode). |
| `date` | string | `2026-08-29` | `YYYY-MM-DD` for fixtures mode. |
| `daysAhead` | integer | `0` | Extra days after `date`. |
| `leagueIds` | array | `["47"]` | League ids or names (league mode, fixtures scoping). |
| `season` | string | (current) | Season label for league mode. |
| `teamIds` | array | `["10252"]` | Team ids or names (team mode). |
| `playerIds` | array | `["268375"]` | Player ids or names (player mode). |
| `newsPages` | integer | `2` | Listing pages to walk, 20 articles each (news mode). |
| `includePlayerStats` | boolean | `true` | Flat per-player stat rows + top players. |
| `includeEvents` | boolean | `true` | Goals, cards, subs + shotmap. |
| `includeLineups` | boolean | `true` | Starters, subs, formations, coach. |
| `includeTeamStats` | boolean | `true` | Possession, shots, xG groups. |
| `includeH2H` | boolean | `false` | Head-to-head + league table snapshot. |
| `includeRawData` | boolean | `false` | Full embedded page payload. |
| `includeNewsBody` | boolean | `true` | Full article text as `bodyHtml` + plain-text `bodyText` (news mode; FotMob-native articles only — syndicated embeds carry no body). |
| `maxItems` | integer | `20` | Stop after this many records (`0` = no limit). |
| `resumeFromRunId` | string | (none) | Continue one interrupted run. |
| `incrementalMode` | boolean | `false` | Return only new and changed records on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode state. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged records. |
| `emitExpired` | boolean | `false` | Also return (and bill) expired records. |
| `ignoreFieldsForChanges` | array | (none) | Fields that never mark a record UPDATED. |
| `proxy` | object | Apify Proxy | Connection settings. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

**Match record for Aston Villa vs Manchester United (illustrative values):**

```json
{
 "type": "match",
 "id": 4506324,
 "matchId": 4506324,
 "matchName": "Aston Villa-vs-Manchester United_Sun, Oct 6, 2024, 13:00 UTC",
 "matchUrl": "https://www.fotmob.com/match/4506324",
 "leagueId": 47,
 "leagueName": "Premier League",
 "round": "7",
 "roundName": "7",
 "countryCode": "ENG",
 "matchTimeUtc": "2024-10-06T13:00:00.000Z",
 "started": true,
 "finished": true,
 "homeTeam": {"id": 10252, "name": "Aston Villa", "score": 0},
 "awayTeam": {"id": 10260, "name": "Manchester United", "score": 0},
 "venue": {"name": "Villa Park", "city": "Birmingham", "capacity": 42788},
 "referee": "Robert Jones",
 "attendance": 42682,
 "playerOfTheMatch": {"playerId": 268375, "name": "Emiliano Martinez", "teamName": "Aston Villa"},
 "teamStats": [{"group": "Top stats", "title": "Ball possession", "key": "BallPossesion", "home": 54, "away": 46}],
 "events": [{"type": "Card", "minute": 3, "minuteLabel": "3", "isHome": false, "playerName": "Christian Eriksen", "card": "Yellow"}],
 "lineups": {"home": {"teamName": "Aston Villa", "formation": "4-4-1-1", "coach": "Unai Emery"}},
 "playerStats": [{"playerId": 268375, "playerName": "Emiliano Martinez", "rating_title": 8.14}],
 "source": "fotmob",
 "scrapedAt": "2024-10-06T00:00:00Z"
}
```

### Plan Requirement

The default proxy setting works out of the box, and the actor rotates connections automatically when one is refused. For large or frequent runs, the residential proxy group gives more headroom; pick it under Connection. If your Apify plan does not include proxy access, the run fails with a clear message instead of returning an empty result; a paid plan with proxy access is required.

### FAQ

#### How much does it cost?

You pay a tiered rate per result returned (the **Pricing** tab shows the per-plan rates). News articles whose full text was read bill one small enrichment surcharge each. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape FotMob?

This actor collects only publicly available football data. You are responsible for how you use it: follow FotMob's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Match results and statistics are generally facts, but logos, photos and shot data may be subject to third-party rights.

#### Can I get only new or changed matches on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records, and unchanged ones are not billed.

#### Why did a fixtures run return fewer matches than the full day?

Fixtures mode discovers matches through the tracked leagues' fixtures (`leagueIds`, default Premier League). Add more league ids to widen the day, and raise **Max items** so nothing is cut off.

#### Do I need to know FotMob's numeric ids?

No. `leagueIds`, `teamIds` and `playerIds` also accept names (e.g. `"Arsenal"`, `"Lionel Messi"`, `"Premier League"`) and are resolved to the right id automatically. An unresolvable name is skipped with a warning rather than silently guessed.

#### Why did my run fail instead of returning an empty dataset?

If the site refuses every request, the run stops with a clear message so "no matches today" is never confused with "nothing could be read". Run it again in a few minutes. If only some targets could be read, you still get what was found.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more sports data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>⚽ <a href="https://apify.com/abotapi/sofascore-scraper"><b>SofaScore Scraper ⚽ Live Scores, Stats, Players &amp; Odds</b></a><br>From $1/1K. Pull structured sports data from SofaScore across football, basketball...</td><td>⚽ <a href="https://apify.com/abotapi/onefootball-com-scraper"><b>OneFootball Scraper</b></a><br>Scrape public OneFootball data including football news, upcoming fixtures, match results...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/sportsbook-odds-scraper"><b>Sportsbook Odds Scraper (1xBet, Melbet, Linebet, Paripulse)</b></a><br>Collect live and prematch betting odds from 1xBet, Melbet, Linebet and Paripulse. Give it...</td><td>⚽ <a href="https://apify.com/abotapi/globo-ge"><b>Globo Esporte Scraper</b></a><br>Scrape public sports content from ge.globo.com, including news, videos, matches and feed...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/eventim-de-event-scraper"><b>Eventim Scraper</b></a><br>Scrape CTS Eventim Germany and EU event catalogue: concerts, festivals, comedy, sports...</td><td>⚽ <a href="https://apify.com/abotapi/bookmyshow-scraper"><b>BookMyShow Scraper</b></a><br>Scrape BookMyShow movies and live events by city, category or URL. Extract genres...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/fotmob-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

How to discover what to scrape. News reads the latest football headlines (the default: at least 20 results out of the box). Matches by id reads the match links you list below. Paste FotMob URLs reads any mix of match, team, player and league links. Fixtures by date finds every match played on a date. League, Team and Player scrape those pages directly.

## `matchIds` (type: `array`):

Only used when Mode = Matches by id. One entry per match: a FotMob match id (e.g. 4506324) or a full match link (e.g. https://www.fotmob.com/match/4506324). Each entry becomes one rich match record.

## `urls` (type: `array`):

Only used when Mode = Paste FotMob URLs. Paste any mix of match links (/match/<id>), team links (/teams/<id>/overview/...), player links (/players/<id>/...) and league links (/leagues/<id>/overview/... — /table, /fixtures and /stats tabs work too). Each link is routed to its own scraper automatically; anything else is skipped with a warning.

## `date` (type: `string`):

Only used when Mode = Fixtures by date. Day to pull fixtures for, in YYYY-MM-DD (e.g. 2026-08-29). Matches are found through the leagues listed below, filtered to this date.

## `daysAhead` (type: `integer`):

Only used when Mode = Fixtures by date. Also pull fixtures for this many days after the date above. 0 = just the one day (max 14).

## `leagueIds` (type: `array`):

Used by Mode = League tables & fixtures (the leagues to scrape) and Mode = Fixtures by date (the leagues to search for matches). FotMob league ids (e.g. 47) or plain names (e.g. "Premier League" — resolved automatically).

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

Only used when Mode = League tables & fixtures. Season label exactly as shown on the league page (e.g. 2026/2027). Leave empty for the current season.

## `teamIds` (type: `array`):

Only used when Mode = Team squads. FotMob team ids (e.g. 10252) or plain names (e.g. "Arsenal" — resolved automatically). Each team yields its squad, form, fixtures and table.

## `playerIds` (type: `array`):

Only used when Mode = Player profiles. FotMob player ids (e.g. 268375) or plain names (e.g. "Lionel Messi" — resolved automatically). Each player yields career history, trophies and recent matches.

## `newsPages` (type: `integer`):

Only used when Mode = News articles. How many pages of the latest-news listing to walk (20 articles per page — 2 pages guarantees at least 20 results). The Max records cap below still governs the final count.

## `includePlayerStats` (type: `boolean`):

Match records only. Include the flat per-player stat rows (ratings, goals, saves, passes, xG) plus top players.

## `includeEvents` (type: `boolean`):

Match records only. Include goals, cards and substitutions plus the shot-by-shot shotmap (xG per shot).

## `includeLineups` (type: `boolean`):

Match records only. Include starters, subs, formations and coach for both sides.

## `includeTeamStats` (type: `boolean`):

Match records only. Include possession, shots, passes, xG and every other team stat group.

## `includeH2H` (type: `boolean`):

Match records only. Include past meetings between the two teams plus the league-table snapshot carried on the match page. Off by default: it makes records much larger.

## `includeRawData` (type: `boolean`):

Include the full embedded page payload under rawData. Large — turn on only when you need every field.

## `includeNewsBody` (type: `boolean`):

Only used when Mode = News articles. Fetch the full article text for each news record (one extra request per article, no extra per-record charge). Adds bodyHtml plus plain-text bodyText and fills in the lead. Works for FotMob-native articles (/news/...); syndicated embeds (/embed/news/...) are iframes to the publisher's site and carry no body on FotMob's side.

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

Stop after this many records across the whole run (0 = no limit). Use it to cap run size and cost.

## `proxy` (type: `object`):

Connection used for every request. FotMob answers on the standard pool and the scraper rotates sessions automatically when refused. Residential is recommended for large or frequent runs.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue that interrupted run without returning or charging for records already collected there. For recurring monitoring of the same scope, use Recurring updates below instead — leave this empty.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching records as NEW. Later runs return only NEW, UPDATED and REAPPEARED records. Turn on Also-return options below only when you also want those extra records returned (and billed).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its memory stable, or to deliberately share memory across differently configured runs. Leave empty to key the memory on this run setup automatically.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present before but are no longer found, marked EXPIRED. Only produced when a run covered its whole setup, so a capped or continued run never reports records as gone.

## `ignoreFieldsForChanges` (type: `array`):

Output field names that should NOT mark a record as UPDATED. scrapedAt is always ignored because it is stamped fresh on every fetch. Add fields such as teamForm here if changes to them are not relevant to you. Ignored fields are still returned in the output.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "news",
  "matchIds": [
    "4506324"
  ],
  "urls": [
    "https://www.fotmob.com/match/4506324",
    "https://www.fotmob.com/teams/10252/overview/aston-villa",
    "https://www.fotmob.com/players/268375/emiliano-martinez",
    "https://www.fotmob.com/leagues/47/overview/premier-league"
  ],
  "date": "2026-08-29",
  "daysAhead": 0,
  "leagueIds": [
    "47"
  ],
  "teamIds": [
    "10252"
  ],
  "playerIds": [
    "268375"
  ],
  "newsPages": 2,
  "includePlayerStats": true,
  "includeEvents": true,
  "includeLineups": true,
  "includeTeamStats": true,
  "includeH2H": false,
  "includeRawData": false,
  "includeNewsBody": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# 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 = {
    "mode": "news",
    "matchIds": [
        "4506324"
    ],
    "urls": [
        "https://www.fotmob.com/match/4506324",
        "https://www.fotmob.com/teams/10252/overview/aston-villa",
        "https://www.fotmob.com/players/268375/emiliano-martinez",
        "https://www.fotmob.com/leagues/47/overview/premier-league"
    ],
    "date": "2026-08-29",
    "leagueIds": [
        "47"
    ],
    "teamIds": [
        "10252"
    ],
    "playerIds": [
        "268375"
    ],
    "newsPages": 2,
    "includeNewsBody": true,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/fotmob-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 = {
    "mode": "news",
    "matchIds": ["4506324"],
    "urls": [
        "https://www.fotmob.com/match/4506324",
        "https://www.fotmob.com/teams/10252/overview/aston-villa",
        "https://www.fotmob.com/players/268375/emiliano-martinez",
        "https://www.fotmob.com/leagues/47/overview/premier-league",
    ],
    "date": "2026-08-29",
    "leagueIds": ["47"],
    "teamIds": ["10252"],
    "playerIds": ["268375"],
    "newsPages": 2,
    "includeNewsBody": True,
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/fotmob-scraper").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 '{
  "mode": "news",
  "matchIds": [
    "4506324"
  ],
  "urls": [
    "https://www.fotmob.com/match/4506324",
    "https://www.fotmob.com/teams/10252/overview/aston-villa",
    "https://www.fotmob.com/players/268375/emiliano-martinez",
    "https://www.fotmob.com/leagues/47/overview/premier-league"
  ],
  "date": "2026-08-29",
  "leagueIds": [
    "47"
  ],
  "teamIds": [
    "10252"
  ],
  "playerIds": [
    "268375"
  ],
  "newsPages": 2,
  "includeNewsBody": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}' |
apify call abotapi/fotmob-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/fotmob-scraper"
        }
    }
}
```

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/1LEAD7lZbByj5SKZ7/builds/3cA2xtd8xZ16LftOX/openapi.json