Skip to main content
Glama
Fantasy Premier League MCP Server

Fantasy Premier League MCP Server

Fantasy Premier League MCP Server

A comprehensive Model Context Protocol (MCP) server for Fantasy Premier League analysis and strategy. This server provides AI assistants with powerful tools, resources, and prompts to help you dominate your FPL mini-leagues with data-driven insights.

PyPI Python 3.13+ License: MIT MCP Document

Features

This MCP server provides comprehensive FPL analysis capabilities through:

  • 19 Interactive Tools - Search players, analyze fixtures, compare managers, track transfers, and more

  • 4 Data Resources - access to players, teams, gameweeks, and current gameweek bootstrap data

  • 10 Strategy Prompts - Structured templates for gameweek analysis, squad analysis, transfer planning, chip strategy, lineup selection, and captain selection

  • Smart Caching - 4-hour cache for bootstrap data to minimize API calls while keeping data fresh

  • Fuzzy Matching - Find players even with spelling variations or nicknames

  • Live Transfer Trends - Track the most transferred in/out players for current gameweek

  • Manager Insights - Analyze squads, transfers, and chip usage

  • Fixture Analysis - Assess team fixtures and plan transfers around favorable runs

Related MCP server: FPL MCP Server

Quick Start

The fastest way to get started - no installation required:

{
  "mcpServers": {
    "fpl": {
      "command": "uvx",
      "args": ["fpl-mcp-server"],
      "type": "stdio"
    }
  }
}

Option 2: Docker

Use the official Docker image from GitHub Container Registry:

{
  "mcpServers": {
    "fpl": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/nguyenanhducs/fpl-mcp-server:latest"
      ],
      "type": "stdio"
    }
  }
}

For detailed installation instructions and more options, see Installation Guide.

Usage & Documentation

Once configured, you can interact with the FPL MCP server through Claude Desktop using natural language.

For detailed guidance, see:

Data Sources

This server uses the official Fantasy Premier League API, see here for more details.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Available Tools

19 tools
fpl_analyze_rivalA
Read-onlyIdempotent

Compare your team against a specific rival manager.

Provides a comprehensive head-to-head analysis including:

  • Points and Rank comparison

  • Chip usage history

  • Captaincy comparison

  • Key Differentials (players they own that you don't)

Args: params (AnalyzeRivalInput): Validated input parameters containing: - my_team_id (int): Your team ID - rival_team_id (int): Rival's team ID - gameweek (int | None): Gameweek number (defaults to current)

Returns: str: Detailed rival analysis and threat assessment

Examples: - Compare me vs rival: my_team_id=123, rival_team_id=456 - Analyze past GW: my_team_id=123, rival_team_id=456, gameweek=10

Error Handling: - Returns error if either team ID invalid - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_analyze_team_fixturesA
Read-onlyIdempotent

Analyze upcoming fixtures for a specific Premier League team to assess difficulty.

Shows next N gameweeks with opponent strength and home/away status. Includes average difficulty rating and assessment. Very useful for identifying good times to bring in or sell team assets based on fixture difficulty.

Args: params (AnalyzeTeamFixturesInput): Validated input parameters containing: - team_name (str): Team name to analyze (e.g., 'Arsenal', 'Liverpool') - num_gameweeks (int): Number of gameweeks to analyze, 1-15 (default: 5) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Fixture difficulty analysis with ratings and assessment

Examples: - Next 5 fixtures: team_name="Arsenal" - Next 10 fixtures: team_name="Liverpool", num_gameweeks=10 - Long-term view: team_name="Man City", num_gameweeks=15

Error Handling: - Returns error if team not found - Returns error if no upcoming fixtures - Returns formatted error message if data unavailable

Inputs: params (required). Returns: result

fpl_analyze_transferA
Read-onlyIdempotent

Analyze a potential transfer decision between two players.

Compares the player being transferred out vs the player being transferred in. Analyzes form, upcoming fixtures (next 5), price difference, and overall value. Provides a direct recommendation based on the data.

Args: params (AnalyzeTransferInput): Validated input parameters containing: - player_out (str): Name of player to remove - player_in (str): Name of player to add - my_team_id (int | None): Optional team ID to check budget impact

Returns: str: Detailed transfer analysis and recommendation

Examples: - Analyze move: player_out="Salah", player_in="Palmer" - Check budget: player_out="Saka", player_in="Foden", my_team_id=123456

Error Handling: - Returns error if either player not found - Returns error if players play different positions (unless specified) - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_compare_managersA
Read-onlyIdempotent

Compare multiple managers' teams for a specific gameweek side-by-side.

Shows differences in player selection, captaincy choices, points scored, common players, and unique differentials. Useful for mini-league rivalry analysis and understanding what sets top managers apart.

Args: params (CompareManagersInput): Validated input parameters containing: - manager_names (list[str]): 2-4 manager names to compare - league_id (int): League ID where managers are found - gameweek (int): Gameweek number to compare (1-38)

Returns: str: Side-by-side manager comparison with differentials

Examples: - Compare 2 managers: manager_names=["John", "Sarah"], league_id=12345, gameweek=13 - Compare 4 managers: manager_names=["A", "B", "C", "D"], league_id=12345, gameweek=10

Error Handling: - Returns error if fewer than 2 or more than 4 managers provided - Returns error if any manager not found (with helpful message) - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_compare_playersA
Read-onlyIdempotent

Compare multiple Fantasy Premier League players side-by-side.

Provides detailed comparison of 2-5 players including their stats, prices, form, and other key metrics. Useful for making transfer decisions.

Args: params (ComparePlayersInput): Validated input parameters containing: - player_names (list[str]): 2-5 player names to compare

Returns: str: Side-by-side comparison of players in markdown format

Examples: - Compare wingers: player_names=["Salah", "Saka", "Palmer"] - Compare strikers: player_names=["Haaland", "Isak"] - Compare for transfers: player_names=["Son", "Maddison", "Odegaard"]

Error Handling: - Returns error if fewer than 2 or more than 5 players provided - Returns error if any player name is ambiguous - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_find_fixture_opportunitiesA
Read-onlyIdempotent

Find teams with the easiest upcoming fixtures and their best assets.

Analyzes fixture difficulty for all 20 teams over the next N gameweeks. Identifies teams with the most favorable schedule and recommends their top-performing players (filtered by position if requested).

Args: params (FindFixtureOpportunitiesInput): Validated input parameters containing: - num_gameweeks (int): Number of gameweeks to analyze (3-10) - max_teams (int): Number of teams to recommend (1-5) - positions (list[str] | None): Optional position filter

Returns: str: Analysis of best teams to target and their key players

Examples: - Target next 5 GWs: num_gameweeks=5 - Find best attackers: positions=['Midfielder', 'Forward']

Error Handling: - Returns error if data unavailable - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_find_playerA
Read-onlyIdempotent

Find a Fantasy Premier League player by name with intelligent fuzzy matching.

Handles variations in spelling, partial names, and common nicknames. If multiple players match, returns disambiguation options. More forgiving than exact search.

Args: params (FindPlayerInput): Validated input parameters containing: - player_name (str): Player name with fuzzy support (e.g., 'Haalnd' matches 'Haaland')

Returns: str: Player details if unique match, or list of matching players if ambiguous

Examples: - Find with typo: player_name="Haalnd" (finds Haaland) - Partial name: player_name="Mo Salah" (finds Mohamed Salah) - Surname only: player_name="Son" (finds Son Heung-min)

Error Handling: - Returns helpful message if no players found - Returns disambiguation list if multiple matches - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_captain_recommendationsA
Read-onlyIdempotent

Get captaincy recommendations for the upcoming gameweek.

Analyzes fixtures, form, and home/away advantage to recommend the best captain choices. If team_id is provided, analyzes YOUR specific squad. Otherwise, provides general recommendations from all players.

Args: params (GetCaptainRecommendationsInput): Validated input parameters containing: - team_id (int | None): Your team ID to analyze your specific squad - gameweek (int | None): Gameweek to analyze (defaults to next)

Returns: str: Top 3-5 captain recommendations with analysis

Examples: - Analyze my team: team_id=123456 - General picks for GW15: gameweek=15 - General picks: (no args)

Error Handling: - Returns error if gameweek invalid - Returns helpful message if team ID not found - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_current_gameweekA
Read-onlyIdempotent

Get the current or upcoming Fantasy Premier League gameweek information.

Returns the gameweek that is currently active (before deadline) or the next gameweek (after deadline). Essential for determining which gameweek to plan transfers for and understanding the current state of the season.

Args: params (GetCurrentGameweekInput): Validated input parameters containing: - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Current/upcoming gameweek details with deadline and status

Examples: - Check current GW: response_format="markdown" - Get as JSON: response_format="json"

Error Handling: - Returns error if gameweek data unavailable - Returns error if no active gameweek found - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_fixtures_for_gameweekA
Read-onlyIdempotent

Get all Premier League fixtures for a specific gameweek.

Returns complete fixture list with team names, kickoff times, scores (if finished), and difficulty ratings for both teams. Useful for planning transfers based on fixture difficulty and understanding upcoming matches.

Args: params (GetFixturesForGameweekInput): Validated input parameters containing: - gameweek (int): Gameweek number between 1-38 - detailed (bool): Include detailed stats (default: False) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Complete fixture list with times and difficulty ratings

Examples: - View GW10 fixtures: gameweek=10 - Check upcoming matches: gameweek=15 - Get as JSON: gameweek=20, response_format="json"

Error Handling: - Returns error if gameweek number invalid (must be 1-38) - Returns error if no fixtures found for gameweek - Returns formatted error message if data unavailable

Inputs: params (required). Returns: result

fpl_get_league_standingsA
Read-onlyIdempotent

Get standings for a specific Fantasy Premier League league.

Returns manager rankings, points, team names, and rank changes within the league. Supports pagination for large leagues. Find league ID in the FPL website URL (e.g., for /leagues/12345/standings/ use league_id=12345).

Args: params (GetLeagueStandingsInput): Validated input parameters containing: - league_id (int): League ID from FPL URL - page (int): Page number for pagination (default: 1) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: League standings with rankings and pagination info

Examples: - View league: league_id=12345 - Next page: league_id=12345, page=2 - Get as JSON: league_id=12345, response_format="json"

Error Handling: - Returns error if league not found - Returns error if page number invalid - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_manager_by_team_idA
Read-onlyIdempotent

Get manager profile and squad information using team ID directly.

This tool provides the same functionality as fpl_get_manager_squad but with a name that better reflects its purpose - getting manager information without requiring league context. Shows the 15 players picked, captain/vice-captain choices, formation, points scored, transfers made, and automatic substitutions.

Args: params (GetManagerByTeamIdInput): Validated input parameters containing: - team_id (int): Manager's team ID (entry ID) - gameweek (int | None): Gameweek number (1-38), defaults to current GW - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Complete manager profile with squad, statistics, and team info

Examples: - View current squad: team_id=123456 - View specific gameweek: team_id=123456, gameweek=20 - Get as JSON: team_id=123456, response_format="json"

Error Handling: - Returns error if team ID not found (404) - Returns error if gameweek not started yet - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_manager_chipsA
Read-onlyIdempotent

Get a manager's chip usage showing which chips have been used and which are still available.

Since the 2025/2026 season, FPL provides 4 chips per half-season.

Shows used chips with gameweek and timing, plus remaining available chips. Essential for strategic chip planning and recommendations.

Args: params (GetManagerChipsInput): Validated input parameters containing: - team_id (int): Manager's team ID (entry ID) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Chip usage summary with used and available chips

Examples: - Check chip status: team_id=123456 - JSON format: team_id=123456, response_format="json"

Error Handling: - Returns error if team ID invalid - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_manager_gameweek_teamA
Read-onlyIdempotent

Get a manager's team selection for a specific gameweek.

Shows the 15 players picked, captain/vice-captain choices, formation, points scored, transfers made, and automatic substitutions. Find manager by their name or team name within a specific league.

Args: params (GetManagerGameweekTeamInput): Validated input parameters containing: - manager_name (str): Manager's name or team name - league_id (int): League ID where manager is found - gameweek (int): Gameweek number (1-38)

Returns: str: Complete team sheet with starting XI, bench, and statistics

Examples: - View team: manager_name="John Smith", league_id=12345, gameweek=13 - Check transfers: manager_name="FC Warriors", league_id=12345, gameweek=15

Error Handling: - Returns error if manager not found in league - Returns helpful message suggesting correct name if ambiguous - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_manager_squadA
Read-onlyIdempotent

Get a manager's squad selection for a specific gameweek using their team ID.

Shows the 15 players picked, captain/vice-captain choices, formation, points scored, transfers made, and automatic substitutions. This is a simpler alternative to fpl_get_manager_gameweek_team that uses team ID directly instead of requiring manager name and league ID lookup.

Args: params (GetManagerSquadInput): Validated input parameters containing: - team_id (int): Manager's team ID (entry ID) - gameweek (int | None): Gameweek number (1-38), defaults to current GW - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Complete team sheet with starting XI, bench, and statistics

Examples: - View current team: team_id=123456 - View specific gameweek: team_id=123456, gameweek=13 - Get as JSON: team_id=123456, gameweek=15, response_format="json"

Error Handling: - Returns error if team ID not found - Returns error if gameweek not started yet - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_manager_transfers_by_gameweekA
Read-onlyIdempotent

Get all transfers made by a specific manager in a specific gameweek.

Shows which players were transferred in and out, transfer costs, and timing. Useful for analyzing manager strategy and understanding when/why they made moves. Requires manager's team ID (entry ID) which can be found in the FPL URL.

Args: params (GetManagerTransfersByGameweekInput): Validated input parameters containing: - team_id (int): Manager's team ID (entry ID) - gameweek (int): Gameweek number (1-38)

Returns: str: Complete transfer history for the gameweek with costs

Examples: - View transfers: team_id=123456, gameweek=20 - Check costs: team_id=789012, gameweek=15

Error Handling: - Returns error if team ID invalid - Returns message if no transfers in gameweek - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_player_detailsA
Read-onlyIdempotent

Get comprehensive information about a specific Fantasy Premier League player.

Returns detailed player information including price, form, team, position, upcoming fixtures with difficulty ratings, recent gameweek performance, popularity, and season stats. Most comprehensive player tool.

Args: params (GetPlayerDetailsInput): Validated input parameters containing: - player_name (str): Player name (e.g., 'Mohamed Salah', 'Erling Haaland')

Returns: str: Comprehensive player information with fixtures, form, and stats

Examples: - Get player info: player_name="Mohamed Salah" - Check fixtures: player_name="Bukayo Saka" - Review form: player_name="Erling Haaland"

Error Handling: - Returns error if player not found - Suggests using fpl_find_player if name is ambiguous - Returns formatted error message if API fails

Inputs: params (required). Returns: result

fpl_get_top_performersA
Read-onlyIdempotent

Get top 10 Fantasy Premier League performers over recent gameweeks.

Analyzes player performance over the last N gameweeks and returns the top 10 players for each metric: Goals, Expected Goals (xG), Assists, Expected Assists (xA), and Expected Goal Involvements (xGI). Perfect for identifying in-form players for transfers.

Args: params (GetTopPlayersByMetricInput): Validated input parameters containing: - num_gameweeks (int): Number of recent gameweeks to analyze, 1-10 (default: 5) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Top 10 players for each metric with their stats and team info

Examples: - Last 5 gameweeks: num_gameweeks=5 - Last 10 gameweeks: num_gameweeks=10 - Get as JSON: num_gameweeks=5, response_format="json"

Error Handling: - Returns error if no finished fixtures in range - Gracefully handles API failures for individual fixtures - Returns formatted error message if data unavailable

Note: This tool might take a few seconds to complete due to the number of data points it needs to process.

Inputs: params (required). Returns: result

fpl_get_top_transferred_playersA
Read-onlyIdempotent

Get the most transferred in and out players for the current gameweek.

Shows live transfer trends to identify popular moves happening right now. Uses real-time data from bootstrap for instant response. Essential for understanding the current template and finding differentials.

Args: params (GetTopTransferredPlayersInput): Validated input parameters containing: - limit (int): Number of players to return, 1-50 (default: 10) - response_format (ResponseFormat): 'markdown' or 'json' (default: markdown)

Returns: str: Top transferred in and out players with net transfers

Examples: - Top 10: limit=10 - Top 20: limit=20 - Get as JSON: limit=15, response_format="json"

Error Handling: - Returns error if no transfer data available - Returns formatted error message if current gameweek unavailable

Inputs: params (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 19 tools

    Disambiguation3/5

    Tools are mostly distinct but there is clear overlap between fpl_get_manager_squad and fpl_get_manager_by_team_id, which are described as providing the same functionality. Also fpl_get_manager_gameweek_team overlaps partially. This creates ambiguity for an agent.

    Naming Consistency4/5

    All tools use the 'fpl_' prefix and mostly follow verb_noun pattern. However, inconsistencies exist: fpl_get_manager_by_team_id is verbose and uses a different structure, while fpl_get_manager_squad vs fpl_get_manager_by_team_id are inconsistent naming for same functionality.

    Tool Count4/5

    19 tools is on the higher side for an MCP server, but the domain of FPL is complex and warrants many tools. Some redundancy (e.g., duplicate squad tools) could be reduced, but overall the count is reasonable.

    Completeness4/5

    The server covers a wide range of FPL analysis needs: player info, fixtures, transfers, rivalries, leagues, captaincy. Missing write operations (e.g., making transfers) but that's acceptable for an analysis tool. Minor gap: no explicit chip recommendation tool beyond captain.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables interaction with Fantasy Premier League data through natural language queries. Supports retrieving fixtures, league standings, player performance, and other FPL statistics via the official FPL API.
      16
      13 npm
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Connects LLMs to the Fantasy Premier League API for intelligent team management, enabling natural language player research, competitor analysis, transfer decisions, and strategic planning using friendly names instead of IDs.
      3
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables Fantasy Premier League squad management with custom tools for player search, fixture outlook, tier classification, hit math, and chip timing, all using public FPL data without requiring login credentials.
      1
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides tools and resources to interact with the Fantasy Premier League API, enabling player analysis, fixture insights, and team management through natural language.
      63 npm
      MIT