Building an AI Fantasy Assistant: Reverse Engineering ESPN's API

Not separate tools you have to choose between.

A conversational system where you ask questions in plain English, and the AI automatically routes to the right tool, fetches the data it needs, and gives you actionable analysis.

Ask "Who should I start this week?" and it:

Ask "What trades can I make?" and it:

The key innovation was removing the friction.

No dropdown menus, no selecting which feature you want.

Just chat, and the system figures out what you need.

This required three main components working together:

ESPN doesn't have a public API.

I reverse engineered their undocumented endpoints to pull live data.

The chat interface doesn't just pass your message to GPT-4.

It intelligently routes to specialized tools based on intent:

Each function has its own data requirements and prompting strategy.

This is deployed where others can access it.

I implemented a $10/hour spending cap to prevent runaway OpenAI costs:

This process works for ESPN, DoorDash, Netflix, LinkedIn, whatever.

The steps are always the same.

Press F12 or right-click and hit "Inspect", then go to the Network tab.

My process:

For ESPN, I found:

lm-api-reads.fantasy.espn.com/apis/v3/games/ffl/seasons/2025/segments/0/leagues/{LEAGUE_ID}

Click on the request to see everything.

Headers show authentication methods, required custom headers, browser info.

URL Parameters reveal filtering, pagination, sorting options.

Request Body (for POST) shows expected data format.

Most APIs require authentication.

Common methods:

Cookie-Based: Look in DevTools under Application → Cookies. Copy the values.

Token-Based: Check for Authorization headers like Authorization: Bearer <token>.

API Keys: Sometimes in URL parameters or custom headers.

Store these in environment variables, never commit to version control.

Make the same request programmatically.

Key things:

I use Python's requests library with a Session to maintain cookies, add custom headers, and make authenticated GET requests.

APIs use nested data structures and numeric IDs.

ESPN uses numeric IDs everywhere:

I built mapping dictionaries by:

This is where the real work begins.

Rate Limiting: I limit to 30 requests/minute for ESPN.

Caching: League settings cached all season, projections for 15 minutes.

Error Handling: Retry logic with exponential backoff, graceful failures.

Response Validation: Check fields exist before accessing, handle partial data during live games.

The hard part wasn't reverse engineering ESPN's API.

It was building a chat system that intelligently routes to the right tools.

You can't just pass every message to GPT-4 and let it figure out what to do.

That's expensive and slow.

You need intelligent pre-routing based on user intent.

The chat handler analyzes the incoming message for keywords and context:

Each route triggers different ESPN API calls to gather only the necessary data.

Once intent is detected, the system makes multiple ESPN API calls:

For lineup optimization:

For trade analysis:

This happens in parallel where possible to minimize latency.

After data collection, I transform everything into clean, structured prompts.

Raw ESPN data is a mess for LLMs:

Nested objects, numeric IDs, inconsistent fields.

I built a transformation layer that:

The AI receives formatted data like:

Instead of raw JSON with nested objects.

Fitting everything into the context window required careful engineering.

For a start/bench decision, the agent needs:

That's 3000+ tokens before the AI responds.

I optimized by:

This made the difference between agents that work and agents that hit limits.

Different questions need different analysis approaches.

Lineup Optimizer: Considers variance, not just projections. A high-variance player might be better if you're projected to lose.

Trade Constructor: Scans all league teams to find complementary needs. Generates specific 1-for-1, 2-for-1, or 2-for-2 proposals with reasoning for both sides.

Waiver Wire Analyzer: Filters to only available players, ranks by upside and fit, focuses on weak positions.

Deep Research Agent: Makes web searches for injury reports, weather, defensive matchups. Slower (30-60 seconds) but gives analysis you can't get from projections alone.

Each agent has custom system prompts and output formats.

Building a demo is easy.

Making it work reliably in production is hard.

This is deployed publicly, so I needed protection against runaway costs.

I implemented a $10/hour spending cap:

Before each request:

After each request:

This prevents $500 surprise bills if someone spams the API.

ESPN's API sometimes returns partial data, especially during live games.

I had to handle:

The wrapper validates every field before accessing it and fails gracefully when data is missing.

Nobody wants to wait 30 seconds for a lineup decision.

Optimizations I made:

Most decisions now feel instant despite making multiple API calls and AI requests.

The chat interface needs to remember previous messages.

I use Streamlit session state to persist:

This lets you ask follow-up questions like "What about if I trade for a WR instead?" and the system knows you're continuing the trade analysis conversation.

Backend:

Frontend:

AI:

Disclaimer: This post describes techniques for accessing your own data through undocumented APIs for personal projects. Use responsibly, respect rate limits, and don't access data you don't have permission to view. This is for educational purposes and personal use only.