ESPN Fantasy Football MCP Server
This is a read-only ESPN Fantasy Football MCP server that lets an LLM query league data and give informed fantasy advice.
Inspect league basics: health, league ID/current week, settings, teams, standings, power rankings, draft results.
Analyze weekly matchups: scoreboard, schedules, box scores with starter/bench player detail, and weekly recaps.
Review rosters and lineups: team rosters by week, lineup legality/optimization checks, injuries, byes, and bench analysis.
Explore player availability: free agents/waiver wire, player cards, transactions, FAAB bids, and activity feed.
Interpret league rules: plain-English league profile covering scoring, lineup slots, waivers, playoffs, keepers, and strategic implications.
Get fantasy-football context: glossary-style primer and tool-sequence playbook for common questions.
Run via stdio or authenticated Streamable HTTP with caching, credential hygiene, health checks, and graceful shutdown.
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., "@ESPN Fantasy Football MCP Server Check my lineup for this week and tell me if I should start anyone on the waiver wire."
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.
ESPN Fantasy Football MCP Server
A Model Context Protocol server that puts an ESPN fantasy
football league in front of an LLM. It is a thin, read-only client for
espn-fantasy-football-api-node
and exposes every route in that API's OpenAPI spec as an MCP tool, plus fantasy-football
domain knowledge and ready-made prompts for the questions managers actually ask.
Runtime: Node.js 22 LTS+
SDK:
@modelcontextprotocol/serverv2 (stdio and Streamable HTTP transports)Schemas: Zod v4
No build step — plain ESM JavaScript
Architecture
MCP host (VS Code / Claude / Cursor / Remote agent)
| stdio (JSON-RPC) OR Streamable HTTP (POST /mcp)
v
espn-fantasy-football-mcp-node <-- this repo
| HTTP (fetch)
v
espn-fantasy-football-api-node <-- your Express API
|
v
ESPN fantasy endpointsThis server holds no ESPN logic of its own. It adds schemas, descriptions, caching, credential hygiene and fantasy-football context on top of your HTTP API.
Related MCP server: sleeper-mcp
Setup
npm install
Copy-Item .env.example .envStart your fantasy API first (it must be reachable at FF_API_BASE_URL):
cd ..\espn-fantasy-football-api-node
npm startRunning with stdio (Default)
The default launch mode is stdio, preserving backward compatibility:
npm startOr explicitly specify the transport via CLI:
node src/index.js --transport=stdioIt waits on stdin — that is correct for stdio servers. To poke at it interactively:
npm run inspectRunning with Streamable HTTP
Streamable HTTP exposes an authenticated HTTP MCP service on /mcp.
Start HTTP using CLI arguments (CLI options take precedence over environment variables):
node src/index.js --transport=streamable-http --host=127.0.0.1 --port=3001Or via environment variables:
$env:MCP_TRANSPORT = "streamable-http"
$env:MCP_HOST = "127.0.0.1"
$env:MCP_PORT = "3001"
$env:MCP_AUTH_TOKEN = "your-secure-token"
$env:MCP_ALLOWED_HOSTS = "localhost,127.0.0.1"
npm startOr using the npm script shortcut:
npm run start:httpFor local development without manual token setup, a helper script is available:
node scripts/start-local-http.jsThis helper generates an ephemeral token if MCP_AUTH_TOKEN is unset and binds to loopback (or respects caller-provided MCP_HOST, MCP_PORT, and MCP_ALLOWED_HOSTS).
HTTP Endpoints and Security
MCP Endpoint:
POST /mcp— handles streamable JSON-RPC requests. Requires theAuthorization: Bearer <MCP_AUTH_TOKEN>header and a matchingHostheader listed inMCP_ALLOWED_HOSTS. Non-POST requests return405 Method Not Allowed.Health & Readiness Check:
GET /healthz— unauthenticated probe that returns200with{"status":"ok"}when healthy and accepting requests, and503with{"status":"draining"}during shutdown.Security Protections: HTTP mode requires
MCP_AUTH_TOKENandMCP_ALLOWED_HOSTS. If either is missing, the server fails immediately at startup with an informative error rather than silently disabling authentication. OptionalMCP_ALLOWED_ORIGINSrestricts browser CORS origins.Host Binding: Set
--hostorMCP_HOSTto127.0.0.1for local loopback (default) or0.0.0.0for containerized environments.Graceful Shutdown: On
SIGTERMorSIGINT, the HTTP server immediately enters draining mode (/healthzreturns503), stops accepting new connections, drains existing in-flight tool requests, and closes idle keep-alive connections. Active requests are allowed up toMCP_SHUTDOWN_TIMEOUT_MS(default 55s) before connections are closed.
Stdio advertises capabilities.tools.listChanged: true. The SDK automatically sends
notifications/tools/list_changed when a registered tool definition changes; there is no
unsolicited startup notification. Clients should refresh tools/list after that notification.
The stateless HTTP transport does not support server push to idle clients. After deploying changed
tool definitions, reconnect or restart the MCP client connection and request tools/list again.
Container Deployment
When running this server as a container service alongside your fantasy API:
Container Command:
node src/index.jsRequired Environment Variables:
MCP_TRANSPORT=streamable-httpMCP_HOST=0.0.0.0(binds all container interfaces)MCP_PORT=3001MCP_AUTH_TOKEN=<your-token>(required bearer token)MCP_ALLOWED_HOSTS=<service-name>,localhost,127.0.0.1(acceptedHostheaders)FF_API_BASE_URL=http://<api-service>:3000
Container Runtime Recommendations:
Enable init process (
init: truein Compose ordocker run --init) so Node.js receivesSIGTERMandSIGINTsignals properly.Set container stop grace period to at least
60s(stop_grace_period: 60s) so the default 55-second draining deadline can finish in-flight tool executions beforeSIGKILL.Add a healthcheck targeting
GET /healthz:healthcheck: test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:'+(process.env.MCP_PORT||3001)+'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"] interval: 30s timeout: 5s retries: 3 start_period: 10s
Example Compose service definition:
services:
fantasy-mcp:
build: .
init: true
restart: unless-stopped
stop_grace_period: 60s
environment:
MCP_TRANSPORT: streamable-http
MCP_HOST: 0.0.0.0
MCP_PORT: "3001"
MCP_AUTH_TOKEN: ${MCP_AUTH_TOKEN:?Set MCP_AUTH_TOKEN}
MCP_ALLOWED_HOSTS: fantasy-mcp,localhost,127.0.0.1
FF_API_BASE_URL: http://fantasy-api:3000
expose:
- "3001"Configuration
Upstream Fantasy API
Variable | Default | Purpose |
|
| Base URL of the fantasy HTTP API. Must be |
| — | Default league. Tools may override it per call. |
| — | Default season year. |
| — | Private-league cookie. Prefer setting this on the API server instead. |
| — | Private-league cookie. Prefer setting this on the API server instead. |
|
| Per-request timeout. |
|
| TTL for the in-memory response cache. |
MCP Runtime & Transport
Variable | CLI Option | Default | Purpose |
|
|
| Transport type: |
|
|
| Bind host for HTTP mode. Use |
|
|
| Listen port for HTTP mode. |
| — | — | Required bearer token for |
| — | — | Required comma-separated hostnames accepted in |
| — | — | Optional comma-separated allowed browser origins for CORS. |
| — |
| Grace period in milliseconds to drain requests during shutdown. |
| — |
| Maximum concurrent in-flight HTTP requests before returning 503. |
Environment variables are read from the process environment. Set them in your MCP client
config (see .vscode/mcp.json) or export them in the shell — this server does not read
.env itself, so use node --env-file=.env src/index.js if you want that.
Integrating into Host Applications
Claude Desktop
Modify your claude_desktop_config.json file to include the following at the top of the JSON document. You can optionally include the env variables here but it's recommended to have them configured in the API itself:
{
"mcpServers": {
"espn-fantasy-football": {
"command": "cmd.exe",
"args": [
"/c",
"npm",
"start",
"--prefix",
"C:\\Git\\espn-fantasy-football-mcp-node"
],
"env": {
"LEAGUE_ID": "123456",
"SEASON_YEAR": "2026",
"ESPN_S2": "xxxxxxxxxxxxxxxxxxx",
"SWID": "{3ac98880-8984-4546-8dab-cdb22e4cc387}"
}
}
},
"preferences": {
...
<snip>
...
}Tools
Every route in the upstream OpenAPI spec is covered.
Tool | Route | What it is for |
|
| Is the API up? Diagnose failures before blaming league config. |
|
| League name, team count, current week. Call this first. |
|
| Scoring format, lineup slots, playoff rules, waiver/FAAB rules. |
|
| Team ids, names, records, PF/PA, divisions. Name → id lookup. |
|
| Ranked records and points for. |
|
| Quality estimate that ignores schedule luck. |
|
| Every pick, bid amount and keeper status. |
|
| One team's roster for one week, with slots and injury status. |
|
| Head-to-head scores for a week. |
|
| Schedule plus matchup type (regular / playoff / consolation). |
|
| Per-player actual vs projected points. The analysis workhorse. |
|
| Waiver claims, adds, drops, trades, FAAB bids. |
|
| Chronological league activity feed. |
|
| Waiver wire and free agents, filterable by position. |
|
| Player card by name or ESPN player id. |
| composite | Start here. Raw ESPN settings translated into plain English. |
| composite | Lineup legality and optimization audit against the league's real slots. |
| composite | Non-healthy designations among the top-N season scorers, injury timing from game logs, and positions each team must fill. Cached 30 min per league/week. |
| composite | Full deterministic weekly recap JSON with scoring, standings, all-play, optimal lineups, transactions, availability, power rankings and validation. |
| composite | All-play records, expected wins and luck delta. |
| composite | Optimal lineups, points left on the bench, swaps and result what-ifs. |
| composite | Deduplicated executed/failed claims, FAAB totals and bidding wars. |
| composite | Next-week roster byes, injury statuses and positional coverage facts. |
| composite | Recap reconciliation checks, including any failures. |
| — | Fantasy primer: formats, scoring, slots, waivers, jargon. |
| — | Which tools to combine for common question types. |
leagueId and year are optional on every tool and fall back to LEAGUE_ID / SEASON_YEAR.
Deterministic weekly recaps
get_recap_data accepts optional week, include_preview, sections, compact,
include_history, include_gap_detail and include_optimal_assignment fields. If week is omitted, it
uses the last completed regular-season week. It returns the league and team identities, week_summary,
scoreboard, standings, season_summary, player highlights and callbacks, bench_analysis,
roster_moves, injuries_and_byes, power_rankings, preview, and validation. Numeric results
are computed by pure functions under recap/; points are accumulated in cents and rounded only for
output. Check validation.passed before writing commentary. The weekly_recap prompt contains the
required writing format and tells the writing model to compute no numbers itself.
Payloads include schema_version (1.2.0). get_recap_schema returns the JSON schema and
section names. By default all sections and null fields remain present. sections selects
top-level sections, always retaining schema_version and meta; an empty list returns only
those two fields. compact: true recursively omits null-valued object fields, preserving arrays,
zero and false. Neither option changes calculations. When selecting team_lineups, its
team_lineups_week metadata is also retained; pending_claims similarly retains
pending_claims_meta with scoring_period, transaction_types_checked and source_count,
even for an empty claims list.
include_history defaults to true; set it to false to omit historical detail.
include_gap_detail defaults to false, returning only actionable gaps; true includes every
starting-slot assessment. include_optimal_assignment defaults to true; false omits both
optimal_assignment and its deprecated assignment alias from bench analysis. Bench swaps
are independent single-swap alternatives, not a simultaneous plan; their gains cannot be summed.
team_lineups contains actual recap-week starters, bench and IR players, not optimal assignments.
Each team includes roster_week, starters_total and bench_total. Each player includes
pro_team, injury_status, is_bye_next_week and percent_rostered; unavailable values are
explicitly null in noncompact output, and a false bye flag is retained in compact output.
injury_watch filters injured players by season-points rank <=150, ownership >=60%, or a next-week
starting slot. Season ranks reuse the existing rostered-player ranking; free agents are not ranked.
pending_claims contains next-week pending/canceled waiver or free-agent transactions.
Preview availability is now a {team_id} reference into injuries_and_byes.teams.
Availability and each injury-watch row include injuries_as_of (a timestamp) and roster_week.
Availability metadata identifies slot as an alias of next_week_slot: these are roster snapshot
assignments, not final next-week lineups. week_points always refers to the recap week.
Sentinel pro team None is excluded from availability.
Power-ranking diff_vs_espn is espn_rank - rank: positive means the custom ranking is higher.
Preview next_week_flags uses player-name arrays and includes the open_ir_slots count.
Scoreboard ranks now match standings. Teams retain name and add trimmed display_name.
For compatibility, bidding-war total_bids remains the legacy dollar sum, now also named
total_bid_amount; bid_count is the number of listed bids. Failed bids retain the raw reason
and add a conservative outcome (including unknown when evidence is insufficient).
Executed claims include chronological, per-player acquired_order and acquired_at; their
week points are read only from the claiming team's actual box score.
Generate the sanitized league 380348 / season 2026 Week 7 fixture with
node --env-file=.env scripts/capture-recap-fixture.js while the upstream API is running and
local ESPN_S2 / SWID credentials are configured. This invokes the recap handler with
week: 7, include_preview: true, verifies scope, replaces all owner_name values with
owner_<team_id>, and writes tests/fixtures/recap_w7.json. Never commit raw owner names or cookies.
The recap fetches each scoring week once per request, then requests all next-week rosters together.
Its tool calls leave league IDs and ESPN cookies out of the request so a preconfigured upstream API
can supply them. Existing tools keep their normal client defaults. Team-name snapshots are stored in
.recap-team-name-snapshots.json (or the path in RECAP_TEAM_NAME_CACHE) for rename detection.
Teams and rosters endpoints in some API builds do not expose owner display names; those are returned
as null when unavailable.
The top-level JSON shape is:
{
"meta": {},
"teams": [],
"week_summary": {},
"scoreboard": [],
"standings": [],
"season_summary": {},
"players": { "studs": [], "duds": [], "bench_top": [], "qb_flips": [] },
"bench_analysis": { "teams": [], "league_total_left": 0, "what_ifs": [] },
"roster_moves": { "teams": [], "bidding_wars": [], "league_faab_total": 0 },
"injuries_and_byes": { "bye_teams": [], "teams": [] },
"power_rankings": [],
"preview": [],
"validation": { "passed": true, "checks": [] }
}Refresh live raw-response fixtures while the local API is running on port 3000:
node scripts/refresh-recap-fixtures.jsThis captures weeks 1-4, week 4 transactions, week 5 matchups/rankings and every team roster for
week 5 under tests/fixtures/. The fixture files are raw API JSON; the test suite uses them for the
week 4 golden values and lineup solver cross-checks.
The interpreter tools
ESPN speaks in integers: scoring is statId → points, lineups are slotId → count. Neither is
usable by a model without translation, and the failure mode is silent — a league with two FLEX
spots and an IR slot looks identical to a standard league until you decode slot IDs 23 and 21.
get_league_profile does that decoding in one call:
Scoring — PPR value (standard / half / full / custom), passing-TD value, interception penalty, active yardage bonuses, and every scoring rule grouped by category. Any rule ESPN reports that cannot be labeled is listed explicitly rather than silently dropped.
Roster — the exact starting lineup with eligible positions per slot, FLEX count, superflex detection, bench and IR counts, and total roster size.
Rules — FAAB vs rolling waivers with budget and process day/hour, acquisition limits, trade deadline, veto rules, playoff team count and first playoff week, median scoring, keepers.
Strategic implications — what those specific rules mean for how the league should be played.
check_lineup cross-references a roster against those slots and player availability, returning
severity-ranked issues:
Severity | Detects |
error | Unfilled starting slots, starters on bye, OUT/DOUBTFUL starters, a player illegally occupying IR |
warning | Questionable starters, bench players outscoring a starter they may legally replace |
info | Injured bench players eligible for an open IR slot |
Slot eligibility is checked against ESPN's own eligible_slots for each player, not against
position labels, so unusual flex configurations are handled correctly.
Prompts
Slash-command style entry points for the questions people actually ask:
start-sit, waiver-wire-targets, trade-evaluation, matchup-preview, weekly-recap,
weekly-recap-email, power-rankings-writeup, playoff-outlook, roster-checkup, draft-review,
league-briefing, explain-my-league, lineup-legality-check, ir-and-bench-optimization,
scoring-quirks, format-adjusted-rankings.
Each one is preloaded with the answering rules — start from the league profile, never assume a standard league, never request box scores for a future week, know whether a projection is seasonal or weekly, separate skill from schedule luck, and do not invent NFL news.
Resources
URI | Contents |
| How fantasy football works, end to end. |
| Question → tool-sequence playbook. |
| Decoder for slot IDs, stat IDs, injury statuses, transaction types. |
| The interpreted league profile. |
| The live upstream OpenAPI document. |
| Snapshot of the configured league. |
Known data traps
These are encoded in the server instructions and the ESPN code reference, but are worth knowing:
A roster player's
projected_pointsandtotal_pointsare season figures (scoring period 0). Useavg_points/projected_avg_pointsper game, orget_box_scoreswithincludeLineup: truefor true weekly projections.active_statusinitializes to'bye'and only resolves once real stats exist, so every player reads as on-bye before kickoff. Useon_bye_weekandinjury_statusfor availability.on_bye_weekis derived from the absence of a scheduled game, so missing schedule data makes an entire roster look like it is on bye.check_lineupdetects this case and reports it rather than emitting a dozen bogus bye warnings.percent_ownedof-1means "no data reported", not 0% ownership.
Security notes
ESPN cookies are never tool inputs. The upstream API accepts
espnS2/swidas query parameters, but exposing them as tool arguments would put credentials into model context. They are read from the environment only, and are masked in every error message and log line.Because the upstream API takes those cookies on the query string, the safest setup is to configure
ESPN_S2/SWIDon the API server and leave them unset here.FF_API_BASE_URLis validated tohttp/httpsand has any embedded user:password stripped.All tools are read-only and annotated as such; nothing in this server can modify a league.
Responses are cached in memory only, for
FF_CACHE_TTL_MS, and never written to disk.
Development
npm testTests cover URL construction, credential redaction, configuration validation, league-profile interpretation (half-PPR vs superflex detection, multi-FLEX and IR slot counts, unmapped scoring IDs) and every lineup-audit rule.
Upstream API requirements
get_league_profile and check_lineup need settings.lineup_slots from the API, which keys
lineup counts by ESPN slot ID. Against an older API build that does not expose it, both tools
degrade with an explicit warning rather than reporting wrong slot counts.
Available Tools
19 toolscheck_lineupLineup legality and optimization checkARead-only
Audit a team's lineup for a week against the league's real slot requirements and player availability. Detects: unfilled starting slots that would score zero, starters on a bye, starters who are OUT or DOUBTFUL, questionable starters needing a kickoff check, players illegally occupying an IR slot (which blocks lineup submission in ESPN), injured bench players who could be stashed on an open IR slot to free a bench spot, and bench players outscoring a starter they are eligible to replace. Use this for "is my lineup set", "am I missing anything", and IR or bench optimization questions.
Inputs: week (required), teamId (required), year, leagueId.
explain_fantasy_footballFantasy football primerARead-only
Get background on how fantasy football works: the season structure, scoring formats (PPR vs standard), lineup slots, waivers and FAAB, injury designations, strategy vocabulary and league types. Call this when a question uses fantasy jargon you are not confident about, or before giving advice in an unfamiliar league format.
Inputs: topic.
get_activityRecent league activity feedARead-only
Get the league activity feed — the chronological "who added/dropped/traded what" log. Best tool for "what did I miss this week" and for newsletter or recap writing. Page through with size and offset.
Inputs: size, year, offset, msgType, +1 more.
get_box_scoresBox scores with lineupsARead-only
Get detailed box scores for a week: actual and projected team scores plus, with includeLineup, every starter and bench player with their points, projected points, slot, pro opponent, bye-week flag and injury status. This is the richest tool here — use it for start/sit review, bench blunders, over/under-performance versus projection and weekly recaps. Requesting a week later than the league current_week fails with an error, so check get_league first.
Inputs: week, year, leagueId, includeLineup.
get_draftDraft resultsARead-only
Get every draft pick with round, pick number, player, drafting team, auction bid amount and keeper status. Use for draft grades, steal/bust analysis, and to see how much a manager originally invested in a player being discussed in a trade.
Inputs: year, leagueId.
get_free_agentsFree agents and waiver wireARead-only
List unrostered players available on the waiver wire or as free agents, with projected points and recent points. This is the tool for "who should I pick up", streaming a defense or kicker, and finding a replacement for an injured starter. Filter by position and raise size to see deeper options.
Inputs: size, week, year, leagueId, +2 more.
get_healthAPI health checkARead-only
Check that the ESPN fantasy football HTTP API this server talks to is reachable. Use this first when other tools fail, to tell "API is down" apart from "bad league config".
Inputs: no named parameters.
get_leagueLeague summaryARead-only
Get the league id, season year, league name, team count and — most importantly — current_week. Call this before any week-scoped question so you know what "this week" means.
Inputs: year, leagueId.
get_league_profileInterpreted league profileARead-only
THE tool to call before giving any fantasy advice. Translates the league's raw ESPN settings into plain English: scoring format (PPR value, passing TD value, active yardage bonuses, every scoring rule grouped by category), the exact starting lineup including how many FLEX slots and whether it is superflex, bench and IR slot counts, roster size, waiver and FAAB mechanics, trade deadline, playoff structure, and a list of strategic implications those rules create. Player value depends entirely on these rules, so call this first rather than assuming a standard league.
Inputs: year, leagueId.
get_matchupsWeekly matchupsARead-only
Get the matchup schedule for a week, including matchup_type (regular season, winners bracket, losers/consolation bracket). Use this to preview who plays whom, including future weeks, and to work out playoff scenarios.
Inputs: week, year, leagueId.
get_player_infoPlayer cardARead-only
Look up a single player by name or ESPN playerId and get their position, pro team, ownership and start percentages, injury status, and scoring. Use the exact full name ("Patrick Mahomes"); if the lookup fails, find the player via get_free_agents or get_roster and use the returned player_id instead.
Inputs: name, year, leagueId, playerId.
get_power_rankingsPower rankingsARead-only
Get computed power rankings through a given week. Power score blends scoring and strength of opponents, so it is a better quality estimate than raw record. Use alongside get_standings to explain who is overperforming their record.
Inputs: week, year, leagueId.
get_rosterTeam roster for a weekARead-only
Get one team's roster for a specific week: player names, positions, lineup slot (starter vs bench), eligible slots, pro team, injury status and ownership percentages. This is the starting point for start/sit, trade and roster-construction questions. Both teamId and week are required.
Inputs: week (required), teamId (required), year, leagueId.
get_scoreboardWeekly scoreboardARead-only
Get head-to-head scores for a week: home/away team names, scores and whether the matchup is a playoff game. Safe to call for future weeks, where scores will be zero. For per-player detail use get_box_scores instead.
Inputs: week, year, leagueId.
get_settingsLeague settings and scoring rulesARead-only
Get league settings: scoring format (PPR / half-PPR / standard and per-stat values), roster and lineup slot counts, playoff team count, playoff week matchup length, waiver/FAAB rules, keeper settings, and divisions. Player value depends entirely on these rules, so read them before ranking, trading or start/sit advice.
Inputs: year, leagueId.
get_standingsLeague standingsARead-only
Get standings ordered by league rank with wins, losses, ties and points_for. Compare points_for against record to spot lucky and unlucky teams.
Inputs: year, leagueId.
get_teamsAll fantasy teamsARead-only
List every fantasy team with team_id, name, abbreviation, record (wins/losses/ties), points for, points against and division. Use this to translate a team name the user typed into the numeric teamId other tools require.
Inputs: year, leagueId.
get_transactionsTransactions for a scoring periodARead-only
Get roster transactions (waiver claims, free-agent adds, drops, trades) for a scoring period, including FAAB bid amounts and whether a claim succeeded or failed. Use this to see what the waiver market paid for a player and which managers are chasing the same needs.
Inputs: year, types, leagueId, scoringPeriod.
how_to_answerQuestion playbookARead-only
Get the recommended tool sequence for common fantasy questions (start/sit, waiver pickups, trade evaluation, playoff odds, weekly recap, draft review). Call this when you are unsure which tools to combine for a question.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Most tools target clearly distinct data, but several overlap: get_settings and get_league_profile both describe league rules and instruct agents to call them first, get_scoreboard/get_matchups/get_box_scores all return week-level matchup data, and get_teams/get_standings both include records. Descriptions mitigate though, and there are no truly interchangeable tools.
The vast majority follow a consistent get_<noun> pattern (get_league, get_roster, get_free_agents). Three exceptions break the pattern: how_to_answer, check_lineup, and explain_fantasy_football. Still easily readable and predictable overall.
Nineteen tools is on the heavy side but justified for read-only ESPN fantasy football, which requires distinct operations for league info, rosters, scores, transactions, and player data. A few tools could be consolidated, but none feel superfluous.
The surface covers nearly everything a fantasy football assistant needs: league context, settings, teams, standings, draft, rosters, weekly scores, matchups, box scores, free agents, player lookup, transactions, activity feed, lineup auditing, and educational help. No major read-only gaps are apparent.
Maintenance
Related MCP Connectors
NFL analytics tools for AI agents: stats, fantasy, injuries, schedules, and advanced analysis.
Fantasy analysis for your ESPN, Yahoo, and Sleeper leagues. Reads your leagues, never changes them.
Fantasy football for any AI agent: draft board, start/sit, waivers, your Sleeper league. Free.
Free fantasy AI for ESPN, Sleeper, Fantrax: football, basketball and hockey in Claude and ChatGPT.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides read-only access to Sleeper fantasy football leagues, enabling team snapshots, available players, matchups, trade context, and league history through standardized MCP tools.MIT
- AlicenseNot gradedqualityBmaintenanceEnables Claude to interact with Sleeper fantasy football leagues via MCP tools for roster, waiver, matchup, and transaction queries, plus a dashboard for daily reports, live scoring, and game-day alerts.79 npmMIT
- FlicenseNot gradedqualityCmaintenanceProvides read-only access to Yahoo Fantasy Football league data through MCP, letting ChatGPT retrieve rosters, standings, scoreboards, draft results, transactions, and player stats without making any roster changes.1-
- FlicenseBqualityCmaintenanceProvides MCP-compatible LLMs with read-only access to normalized ESPN Fantasy Football league snapshots, team rosters, and free-agent data.3-