Fantasy Premier League MCP Server
Provides tools for analyzing Fantasy Premier League data, including player search, fixture analysis, manager comparison, transfer tracking, and strategy prompts.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Fantasy Premier League MCP Server show me the best captain pick for gameweek 6"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
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
Option 1: uvx (Recommended)
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:
Tool Selection Guide - Choose the right tool for your analysis task
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 toolsfpl_analyze_rivalARead-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_fixturesARead-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_transferARead-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_managersARead-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_playersARead-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_opportunitiesARead-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_playerARead-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_recommendationsARead-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_gameweekARead-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_gameweekARead-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_standingsARead-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_idARead-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_chipsARead-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_teamARead-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_squadARead-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_gameweekARead-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_detailsARead-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_performersARead-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_playersARead-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
Scored across 19 tools
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.
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.
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.
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
Related MCP Connectors
Your Fantasy Premier League team in your AI: analyses, injuries, prices, fixtures and player cards.
Fantasy Premier League (FPL) assistant: one clear call on captain, transfers and chips.
FPL data, points predictions, and transfer, captain and chip advice for any team.
NFL analytics tools for AI agents: stats, fantasy, injuries, schedules, and advanced analysis.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables 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.1613 npm3MIT
- AlicenseNot gradedqualityDmaintenanceConnects 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.3MIT
- FlicenseNot gradedqualityCmaintenanceEnables 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-
- AlicenseNot gradedqualityDmaintenanceProvides tools and resources to interact with the Fantasy Premier League API, enabling player analysis, fixture insights, and team management through natural language.63 npmMIT