Espn Fantasy Claude Openclaw

Turn your H2H Categories league into a conversation. Scout opponents, find free agents, analyze trades, run your auction draft, and track your season — all through Claude.

"Who should I pick up at SS this week?"

Claude checks your roster, identifies your weak categories, searches free agents at SS, compares them against your current player, and recommends a pickup that flips two categories in your matchup.

Claude Code

OpenClaw

What You Can Do

Weekly Management

• Matchup scouting — See your H2H category breakdown, identify swing categories, and get lineup recommendations to flip close ones
• Free agent search — Find pickups filtered by position, ranked by category impact (not generic points)
• Waiver wire alerts — Monitor league transactions, spot dropped players worth claiming
• Weekly prep — Full Monday briefing: matchup preview, injury report, start/sit decisions, streaming targets

Trades & Strategy

• Trade analysis — Evaluate any trade with a category-by-category impact table and a clear accept/decline verdict
• Category strategy — Map your strengths and weaknesses across all 14 categories, decide what to punt, and build a path to 8+ category wins per week
• Season outlook — Big-picture analysis: win/loss trajectory, playoff positioning, roster improvement plan

Auction Draft ($280 budget)

• Live draft board — Track every pick, price paid, and remaining budgets across all teams
• Budget strategy — Stars-and-scrubs vs balanced, position scarcity alerts (C, SS), nomination targets
• Bid guidance — For each nominated player: max bid, walk-away price, and alternative targets if you lose

Automated Monitoring (Cron Jobs)

Don't wait until you remember to check — set up scheduled agents to monitor your league on autopilot. Platforms like OpenClaw support cron-based agent execution, so the plugin checks your league on a schedule and alerts you when something needs attention.

Example schedules:

Example prompts for your scheduled agents:

• "Check my roster for injured players, empty slots, or anyone on the bench who should be starting. Flag any issues."
• "Check recent league activity for dropped players worth picking up. Cross-reference with my roster needs and weak categories. Only alert me if there's a clear upgrade."
• "Run a full weekly prep: scout my opponent, identify swing categories, check for streaming pitchers, and give me a game plan for the week."

This turns the plugin from reactive (you ask, it answers) to proactive (it watches your league and tells you when to act).

Cross-Session Memory

The plugin remembers your season across conversations:

Memory is powered by a local SQLite database (~/.espn-fantasy/memory.db) with 14 MCP tools across 7 tables. At the start of each session, the agent loads your full context — matchup history, category trends, roster moves, and preferences — so it picks up where you left off.

How It Works

Two MCP servers working together:

ESPN Fantasy MCP (30 tools + 5 resources) — Connects to ESPN's API for live league data: rosters, standings, matchups, free agents, player stats, trades, draft board, scoring categories, probable pitchers, and transaction counts. Deployed on Railway via SSE or runs locally via stdio.

Memory MCP (14 tools) — Local SQLite server that persists matchup results, roster moves, category assessments, watchlist, draft picks, and user preferences across sessions. Runs locally via stdio.

8 Skills orchestrate both servers into complete workflows. When you ask "How's my matchup this week?", the matchup-scout skill calls get_standings → get_matchup → get_team_roster (opponent) → get_my_roster → loads memory for historical context → produces a category scoreboard with recommendations.

The 14 Scoring Categories

The league uses H2H Categories — you win individual stat categories each week, not total points. This shapes every recommendation:

Built On

• cwendt94/espn-api — Python library for ESPN's Fantasy API (rosters, standings, matchups, player data). This repo is a fork with the MCP server, CLI, and plugin layered on top.
• kalil0321/reverse-api-engineer — Captures ESPN browser traffic to discover undocumented API endpoints beyond what espn-api covers. Used to map additional league data and build more powerful tooling.

Quick Start

Prerequisites

• Python 3.10+
• uv (curl -LsSf https://astral.sh/uv/install.sh | sh)
• ESPN Fantasy Baseball account

Setup

git clone https://github.com/garavitgabriel/espn-api.git
cd espn-api
uv sync

Authenticate

Option A — Browser login (easiest):

uv sync --extra browser              # first time only
uv run playwright install chromium   # first time only
uv run espn auth login

A browser opens, you log in to ESPN, and cookies are captured automatically.

Option B — Manual token:

Get your cookies from ESPN Fantasy > DevTools > Application > Cookies, then:

uv run espn auth token <ESPN_S2> <ESPN_SWID>

Option C — .env file:

cp .env.example .env   # edit with your values

Activate

{
  "mcpServers": {
    "espn-baseball": {
      "command": "uv",
      "args": ["run", "--project", "/path/to/espn-api", "espn-mcp"]
    }
  }
}

Skills

Each skill orchestrates multiple MCP tools into a complete workflow:

CLI

uv run espn standings
uv run espn roster
uv run espn matchup --week 5
uv run espn free-agents --position SS --size 10
uv run espn player "Shohei Ohtani"
uv run espn compare "Shohei Ohtani" "Aaron Judge"
uv run espn trade --give "Player A" --receive "Player B"

# League info
uv run espn schedule --team "Gabriel"
uv run espn settings
uv run espn search "Ohtani"
uv run espn scoreboard --week 5

# Daily lineup decisions
uv run espn probable-pitchers                      # today's MLB starters with handedness
uv run espn sp-schedule "George Kirby"             # next scheduled start
uv run espn vs-team "Freddie Freeman" --opponent SEA  # BvP vs a specific team
uv run espn weekly-moves                           # add/drop count in the current period
uv run espn activity --team "Rolling Bunts" --period 4  # filter league activity

# Draft day
uv run espn scoring
uv run espn slots
uv run espn draft
uv run espn needs

# Auth
uv run espn auth login                        # browser login
uv run espn auth token <ESPN_S2> <ESPN_SWID>  # manual token
uv run espn auth status
uv run espn auth logout

# Plugin bundle
uv run espn build-plugin build --target openclaw
uv run espn build-plugin build --target claude --url https://your-app.up.railway.app/sse

uv run espn --help

MCP Tools (30)

Deploy to Railway

The project includes a Dockerfile and railway.json for one-click deployment.

1. Create the service

1. Push to GitHub
2. Go to railway.com > New Project > Deploy from GitHub Repo
3. Select your fork

2. Set environment variables

In the Railway dashboard, add these variables to your service:

MCP_TRANSPORT=sse is already baked into the Dockerfile — no need to set it manually.

3. Deploy

Railway auto-builds from the Dockerfile. The railway.json configures:

• Build: Dockerfile (uv + Python 3.12, layer-cached deps)
• Start command: /app/.venv/bin/python -m mcp_server.server — uses the venv Python directly (required because Railway may override the Dockerfile CMD)
• Healthcheck: GET /health with a 60s retry window
• Restart policy: on failure, up to 3 retries

4. Connect

Once deployed, your endpoints are:

Use the SSE URL in Claude Desktop, Cowork, or any MCP client:

{
  "mcpServers": {
    "espn-baseball": {
      "type": "url",
      "url": "https://your-app.up.railway.app/sse"
    }
  }
}

Note: The startCommand in railway.json is critical. Railway's Dockerfile builder may ignore the CMD instruction and use a dashboard-configured command instead. The explicit startCommand ensures the venv Python (with all dependencies) is always used.

Architecture

espn-api/
├── .claude-plugin/        # Plugin manifest (auto-discovered by Claude Code)
├── .mcp.json              # MCP server registration (uv run)
├── skills/                # 8 agent-invoked skills
├── commands/              # 5 user-invoked slash commands
├── agents/                # fantasy-advisor agent (H2H Categories expert)
├── memory/                # SQLite memory MCP server (14 tools, 7 tables)
│   ├── server.py          # FastMCP server with 14 memory tools
│   ├── db.py              # Schema + connection management
│   └── repos.py           # Repository pattern for each table
├── espn_api/              # Upstream ESPN Fantasy API library
├── mcp_server/            # ESPN MCP server + CLI
│   ├── server.py          # FastMCP server (30 tools + 5 resources)
│   ├── tools.py           # Tool definitions
│   ├── resources.py       # MCP resource definitions (workflow playbooks)
│   ├── formatters.py      # Shared markdown formatters
│   ├── config.py          # League singleton + credential loading
│   ├── auth.py            # ConfigManager (~/.espn-fantasy/config.json)
│   ├── browser_auth.py    # Playwright-based ESPN login
│   ├── espn_public_api.py # ESPN public API client (player, MLB scoreboard)
│   └── cli/               # Typer CLI (mirrors every MCP tool)
├── pyproject.toml         # uv/hatchling package config
├── Dockerfile             # Production container (Railway-ready)
└── install-openclaw.sh    # OpenClaw one-command installer

Development

uv sync --group dev
uv run pytest
uv run espn --help
uv run espn-mcp  # Start MCP server locally

License

Built on cwendt94/espn-api. See upstream repository for license details.