# Fantasy Premier League Player Stats Scraper (`parseforge/fpl-premier-league-scraper`) Actor

Scrapes official Fantasy Premier League data for players, teams, gameweeks, and fixtures. Returns each record as a flat row with price, points, form, and ownership.

- **URL**: https://apify.com/parseforge/fpl-premier-league-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Fantasy Premier League Player Stats Scraper

**Scrape official Fantasy Premier League player stats, teams, gameweeks, and fixtures in one flat dataset.** Every player row includes price, total points, form, ownership percentage, goals, and assists. Export to CSV, JSON, Excel, or XML.

The Fantasy Premier League website gives you a table you cannot easily export, and the official API returns nested JSON that needs cleaning before you can analyse it. This Actor reads the same public FPL API endpoints and flattens every record into a clean row. You get the data you need for your mini-league dashboard, weekly transfer decisions, or season-long model without writing a single line of code.

| Who uses it | What they scrape Fantasy Premier League for |
|---|---|
| FPL managers | Compare player form, price, and ownership before making a weekly transfer. |
| Content creators | Pull the latest player stats to power a team-selection article or video. |
| Data analysts | Build a season-long dataset of player performance to train a points-prediction model. |
| Mini-league admins | Track team values and player ownership across a private league. |

### What it does

This Actor collects Fantasy Premier League data for players, teams, gameweeks, or fixtures and returns each record as a flat row ready for spreadsheets.

- 👥 **Players:** every footballer with total points, form, price, goals, assists, and ownership percentage.
- 🏟️ **Teams:** the 20 Premier League clubs with their strength ratings and home/away form.
- 📅 **Gameweeks:** the full season schedule with deadlines, average scores, and highest-scoring player per round.
- ⚽ **Fixtures:** every match with kickoff time, gameweek, and the final scoreline.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Fantasy Premier League data

**📊 Build a weekly transfer shortlist.**

An FPL manager runs the Actor on a Friday, sorts midfielders by form, and picks the top five to consider for the upcoming gameweek.

**📈 Track price changes across the season.**

A data analyst schedules a daily run for the Players data type and stores the price column to model market movements.

**📝 Power a team-news blog post.**

A content creator pulls the latest player stats and ownership percentages to write a data-backed article on the most-captained picks.

**🏆 Audit a mini-league.**

A league admin collects the full player list and cross-references ownership to spot the differentials driving the leaderboard.

### Why choose this scraper

|  | What you get |
|---|---|
| **Official FPL data** | Reads the same public API the Fantasy Premier League site uses, so numbers match the game exactly. |
| **Flat, clean rows** | No nested JSON to unpick. Every player, team, gameweek, or fixture is one row you can open in Excel. |
| **Sort before you download** | Order players by total points, form, or price so the most relevant rows land at the top of your dataset. |
| **Team and position filters** | Pull only the midfielders from Arsenal, or every forward in the game, in a single run. |

### How it compares

This Actor returns raw, flat FPL data from the official API. The alternatives below either serve a different source or add a layer of analysis on top of the raw numbers.

| Feature | ParseForge | Transfermarkt Scraper | FPL Intelligence - Picks, Optimizer, Watchlist, History | Football Fixtures Api |
|---|---|---|---|---|
| Official FPL player data | Yes | Not listed | Yes | Not listed |
| Player price, form, and ownership | Yes | Not listed | Yes | Not listed |
| Sort players by points or form | Yes | Not listed | Not listed | Not listed |
| Filter by team and position | Yes | Not listed | Not listed | Not listed |
| Gameweek schedule with deadlines | Yes | Not listed | Not listed | Not listed |
| Weekly captain and transfer picks | Not listed | Not listed | Yes | Not listed |

### Configure the run

Choose the data type you need, then narrow the list by team and position, and sort players by total points, form, price, or goals before setting a row limit. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.004 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.40 |
| 1,000 results | $4.00 |
| 10,000 results | $40.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Fantasy Premier League Player Stats Scraper](https://apify.com/parseforge/fpl-premier-league-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Fantasy Premier League through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/fpl-premier-league-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your Team and Position filters. If you set both to a combination that does not exist, such as a forward for a club that has none listed, the Actor returns an empty dataset. Clear the filters and run again.

**The player prices look wrong.**

The Actor returns the exact values from the official FPL API. Prices are in millions and reflect the current gameweek. A player listed at 12.5 costs 12.5 million.

**I asked for 500 players but only got 200.**

The FPL API returns only the players that exist in the game. If you filter by a single team, you will get at most the squad size for that club. Remove the Team filter to get the full player list.

**The sort order is not what I expected.**

The Actor sorts in descending order, highest first. If you sort by price, the most expensive players appear at the top. Check you have selected the correct field in the Sort Players By dropdown.

**Can I get data for the current gameweek only?**

The Players data type returns the season-long totals. For gameweek-specific deadlines and average scores, switch the Data Type to Gameweeks.

### FAQ

| Question | Answer |
|---|---|
| Where does the data come from? | It reads the same public API endpoints that power the official Fantasy Premier League website, so the numbers match the game exactly. |
| Can I get data for a specific team only? | Yes. Set the Team filter to any Premier League club and the Actor returns only players or fixtures for that side. |
| How do I sort players by form? | Set the 'Sort Players By' dropdown to 'Form' and the Actor orders the output with the most in-form players first. |
| Does this include player prices? | Yes. Every player row includes the current price, selling price, and the price change for the gameweek. |
| Can I get the full season schedule? | Yes. Choose the Gameweeks data type and the Actor returns every gameweek with its deadline and average score. |
| What export formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML from the Apify platform. |
| Do I need an FPL login or API key? | No. The Actor reads the public FPL API endpoints that do not require authentication. |
| Can I get live scores during a match? | The Fixtures data type returns the final scoreline after a match concludes. It does not provide in-play minute-by-minute updates. |
| How many players can I pull in one run? | You can set the maximum up to one million rows, which covers every player in the game many times over. |
| Does this scrape historical FPL data from past seasons? | The Actor returns the current season's data from the live FPL API. It does not access archived seasons. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Premier League. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `dataType` (type: `string`):

Which Fantasy Premier League data set to pull. Players returns every footballer with price, points, form and ownership. Teams returns the 20 clubs. Gameweeks returns the season schedule with deadlines and average scores. Fixtures returns every match with kickoff time and scoreline.

## `team` (type: `string`):

Limit Players or Fixtures to a single club. Leave empty for all 20 clubs. Ignored for Teams and Gameweeks.

## `position` (type: `string`):

Limit Players to one outfield position. Leave empty for all positions. Applies to the Players data type only.

## `sortBy` (type: `string`):

Order for the Players data type, highest first. Applies to the Players data type only.

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

How many players to collect per run.

## Actor input object example

```json
{
  "dataType": "players",
  "team": "",
  "position": "",
  "sortBy": "totalPoints",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fpl-premier-league-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/fpl-premier-league-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 '{
  "maxItems": 10
}' |
apify call parseforge/fpl-premier-league-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/fpl-premier-league-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/UOAjrqpeHqtNGzHLI/builds/dBE2PkQrWcCIysMj7/openapi.json