# Underdog Fantasy MCP server

> Underdog Fantasy MCP server at https://underdogapi.com/api/mcp: 30 tools for lines, multipliers, line history and results. Copy-paste configs for Claude, ChatGPT, Cursor, VS Code, Codex, Gemini and more. Underdog API (https://underdogapi.com) is an independent Underdog Fantasy pick'em data API: Higher/Lower lines with separate payout multipliers per side, line history, changes and graded results as JSON, CSV, MCP and streams.

Canonical page: https://underdogapi.com/mcp

## Free offer

**Free API key, no card: 100 credits a month** on the live board, every league, separate Higher/Lower prices, and the last 24 hours of line history. Sign up: https://underdogapi.com/sign-up?ref=ai-claudebot

## Quickstart

1. Get a free key at https://underdogapi.com/sign-up?ref=ai-claudebot (no card), or let your agent request one: `POST https://underdogapi.com/api/v1/agent/signup` with `data_wanted` and `use_case`, then show your user the returned approval_url.
2. Export it: `export UNDERDOG_API_KEY=ud_...`
3. First call with curl:

```bash
curl --fail-with-body 'https://underdogapi.com/api/v1/projections?league=NBA&view=compact&limit=5' \
  -H "Authorization: Bearer $UNDERDOG_API_KEY" \
  -H 'X-User-Request: NBA dashboard integration check'
```

4. Same call in Python:

```python
import os, requests

r = requests.get(
    "https://underdogapi.com/api/v1/projections",
    params={"league": "NBA", "view": "compact", "limit": 5},
    headers={"Authorization": f"Bearer {os.environ['UNDERDOG_API_KEY']}"},
)
r.raise_for_status()
for line in r.json()["data"]:
    print(line["player"]["name"], line["market"]["stat"], line["line"])
```

## Use it from Claude (MCP)

Claude Code, one command:

```bash
claude mcp add --transport http underdog https://underdogapi.com/api/mcp --header "Authorization: Bearer $UNDERDOG_API_KEY"
```

Or add this server to your Claude MCP configuration (the key stays in the environment):

```json
{
  "mcpServers": {
    "underdog": {
      "type": "http",
      "url": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${UNDERDOG_API_KEY}"
      }
    }
  }
}
```

Guide: https://underdogapi.com/use-with-claude

## Pricing

| Plan | Price | Credits / month | Notes |
| --- | --- | --- | --- |
| Free | $0 | 100 | No card. Live feed 5 minutes behind; last 24 hours of line history |
| Developer | $49/month | 10,000 | For models that need full training pages and loaded game-log seasons. Live feed, no added plan delay |
| Production | $149/month | 50,000 | For apps with real users and push delivery. Everything in Developer, signed webhooks for every change |
| Scale | $499/month | 250,000 | For apps whose traffic has outgrown Production. Everything in Production, 15 live-feed connections at once |

Full pricing: https://underdogapi.com/pricing

## On this page

MCP server · updated November 13, 2026



Short answer: The Underdog Fantasy MCP server is https://underdogapi.com/api/mcp (Streamable HTTP): add that URL to Claude, ChatGPT, Cursor, VS Code, Codex, Gemini CLI or any MCP client with the header Authorization: Bearer <your Underdog API key>, and your agent can read current Underdog pick'em lines, Higher and Lower multipliers, line history and graded results through 30 tools.

## Server facts

| Server URL | https://underdogapi.com/api/mcp |
| --- | --- |
| Transport | Streamable HTTP (stateless JSON over POST) |
| Auth | Authorization: Bearer <key>; without a key: search, fetch, demo and signup tools only |
| Server name | underdog |
| Protocol versions | 2025-06-18, 2025-03-26, 2024-11-05 |
| Tools | 30: current lines, multipliers, alternates, line history, board at a past time, changes, graded results, hit rates, game logs, team and opponent stats, training rows, payouts, injuries, fixtures, players |
| Get a key from the agent | start_signup, then finish_signup after you approve in the browser |
| Cost | Same key and credits as the REST API: Free 100 credits a month, no card |
| Run by | Underdog API (underdogapi.com), an independent data service; not Underdog Fantasy |

[Get a free API key](https://underdogapi.com/sign-up) [API reference](https://underdogapi.com/docs)

## Check the server from a terminal

tools/list works without a key; with one you also get the keyed data tools.

curl

```
curl -s https://underdogapi.com/api/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H "Authorization: Bearer $UNDERDOG_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

## Config for each client

Set UNDERDOG_API_KEY in your environment first. Each block links to the full guide with steps and a first test.

### Claude Code

Add the underdog server to your project's .mcp.json with type http, url https://underdogapi.com/api/mcp and an Authorization header of Bearer ${UNDERDOG_API_KEY}, then check it with /mcp in Claude Code.

.mcp.json

```
{
  "mcpServers": {
    "underdog": {
      "type": "http",
      "url": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${UNDERDOG_API_KEY}"
      }
    }
  }
}
```

[Full Claude Code guide](https://underdogapi.com/use-with-claude)

### Claude (web and desktop)

Add https://underdogapi.com/api/mcp as a custom connector in Claude (Settings, Connectors, Add custom connector). It connects without a key and runs search, fetch and demo tools; for live keyed data use Claude Code.

Claude: Settings > Connectors > Add custom connector

```
Name: Underdog API
Remote MCP server URL: https://underdogapi.com/api/mcp
```

[Full Claude (web and desktop) guide](https://underdogapi.com/use-with-claude-ai)

### OpenAI Codex

Add [mcp_servers.underdog] with url https://underdogapi.com/api/mcp and bearer_token_env_var = "UNDERDOG_API_KEY" to ~/.codex/config.toml; Codex CLI and the IDE extension share it.

~/.codex/config.toml

```
[mcp_servers.underdog]
url = "https://underdogapi.com/api/mcp"
bearer_token_env_var = "UNDERDOG_API_KEY"
```

[Full OpenAI Codex guide](https://underdogapi.com/use-with-codex)

### Cursor

Add the underdog server to .cursor/mcp.json with url https://underdogapi.com/api/mcp and Authorization: Bearer ${env:UNDERDOG_API_KEY}, then check its tools in Cursor's MCP settings.

.cursor/mcp.json

```
{
  "mcpServers": {
    "underdog": {
      "url": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:UNDERDOG_API_KEY}"
      }
    }
  }
}
```

[Full Cursor guide](https://underdogapi.com/use-with-cursor)

### VS Code and GitHub Copilot

Add an HTTP server for https://underdogapi.com/api/mcp to .vscode/mcp.json with an Authorization header filled from a password input, then pick its tools in Copilot Chat agent mode.

.vscode/mcp.json

```
{
  "inputs": [
    {
      "type": "promptString",
      "id": "underdog-api-key",
      "description": "Underdog API key",
      "password": true
    }
  ],
  "servers": {
    "underdog": {
      "type": "http",
      "url": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:underdog-api-key}"
      }
    }
  }
}
```

[Full VS Code and GitHub Copilot guide](https://underdogapi.com/use-with-vscode)

### Windsurf

Add a server with serverUrl https://underdogapi.com/api/mcp and an Authorization header of Bearer ${env:UNDERDOG_API_KEY} to Windsurf's mcp_config.json, then refresh MCP servers in Cascade.

~/.codeium/windsurf/mcp_config.json

```
{
  "mcpServers": {
    "underdog": {
      "serverUrl": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:UNDERDOG_API_KEY}"
      }
    }
  }
}
```

[Full Windsurf guide](https://underdogapi.com/use-with-windsurf)

### Gemini CLI

Add underdog under mcpServers in .gemini/settings.json with httpUrl https://underdogapi.com/api/mcp and an Authorization: Bearer header from UNDERDOG_API_KEY, then run /mcp in Gemini CLI.

.gemini/settings.json

```
{
  "mcpServers": {
    "underdog": {
      "httpUrl": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${UNDERDOG_API_KEY}"
      }
    }
  }
}
```

[Full Gemini CLI guide](https://underdogapi.com/use-with-gemini)

### Zed

In Zed's settings.json add context_servers.underdog with url https://underdogapi.com/api/mcp and an Authorization: Bearer header, then confirm the server is active in the agent panel.

~/.config/zed/settings.json

```
{
  "context_servers": {
    "underdog": {
      "url": "https://underdogapi.com/api/mcp",
      "headers": { "Authorization": "Bearer YOUR_UNDERDOG_API_KEY" }
    }
  }
}
```

[Full Zed guide](https://underdogapi.com/use-with-zed)

### Cline

In Cline's MCP settings add a server with type streamableHttp, url https://underdogapi.com/api/mcp and an Authorization: Bearer header.

cline_mcp_settings.json

```
{
  "mcpServers": {
    "underdog": {
      "type": "streamableHttp",
      "url": "https://underdogapi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_UNDERDOG_API_KEY"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}
```

[Full Cline guide](https://underdogapi.com/use-with-cline)

### Continue

Add an mcpServers entry of type streamable-http with url https://underdogapi.com/api/mcp to Continue's config.yaml and send Authorization: Bearer ${{ secrets.UNDERDOG_API_KEY }} through requestOptions.headers.

~/.continue/config.yaml

```
mcpServers:
  - name: Underdog API
    type: streamable-http
    url: https://underdogapi.com/api/mcp
    requestOptions:
      headers:
        Authorization: Bearer ${{ secrets.UNDERDOG_API_KEY }}
```

[Full Continue guide](https://underdogapi.com/use-with-continue)

### Any MCP client

The Underdog API MCP server is Streamable HTTP at https://underdogapi.com/api/mcp; send Authorization: Bearer <your key>. Clients that cannot send headers get the keyless tools.

Server details

```
Transport: Streamable HTTP (stateless JSON over POST)
URL: https://underdogapi.com/api/mcp
Header: Authorization: Bearer $UNDERDOG_API_KEY
Server name: underdog
Protocol versions: 2025-06-18, 2025-03-26, 2024-11-05
```

[Full Any MCP client guide](https://underdogapi.com/use-with-mcp)

### OpenAI Agents SDK and Responses API

In the OpenAI Agents SDK pass MCPServerStreamableHttp(params={"url": "https://underdogapi.com/api/mcp", "headers": {"Authorization": "Bearer <key>"}}) to your Agent; in the Responses API add a tool of type mcp with that server_url and headers.

agent.py · pip install openai-agents

```
import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(
        name="underdog",
        params={
            "url": "https://underdogapi.com/api/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['UNDERDOG_API_KEY']}"},
        },
    ) as server:
        agent = Agent(
            name="Props analyst",
            instructions="Use the Underdog tools. Quote observed_at. Never invent lines.",
            mcp_servers=[server],
        )
        result = await Runner.run(agent, "Call get_coverage, then get_projections for NBA, view compact, limit 5.")
        print(result.final_output)

asyncio.run(main())
```

[Full OpenAI Agents SDK and Responses API guide](https://underdogapi.com/use-with-openai-agents-sdk)

### LangChain and LangGraph

Use langchain-mcp-adapters: MultiServerMCPClient({"underdog": {"transport": "streamable_http", "url": "https://underdogapi.com/api/mcp", "headers": {"Authorization": "Bearer <key>"}}}), then await client.get_tools() and give the tools to your agent.

agent.py · pip install langchain-mcp-adapters langgraph

```
import asyncio, os
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async def main():
    client = MultiServerMCPClient({
        "underdog": {
            "transport": "streamable_http",
            "url": "https://underdogapi.com/api/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['UNDERDOG_API_KEY']}"},
        }
    })
    tools = await client.get_tools()
    agent = create_react_agent("openai:gpt-5", tools)
    result = await agent.ainvoke({"messages": "Call get_coverage, then get_projections for NBA, view compact, limit 5."})
    print(result["messages"][-1].content)

asyncio.run(main())
```

[Full LangChain and LangGraph guide](https://underdogapi.com/use-with-langchain)

### LlamaIndex

With llama-index-tools-mcp, create BasicMCPClient("https://underdogapi.com/api/mcp", headers={"Authorization": "Bearer <key>"}), turn it into tools with McpToolSpec(client=...).to_tool_list_async(), and give them to your agent.

agent.py · pip install llama-index-tools-mcp

```
import asyncio, os
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

async def main():
    client = BasicMCPClient(
        "https://underdogapi.com/api/mcp",
        headers={"Authorization": f"Bearer {os.environ['UNDERDOG_API_KEY']}"},
    )
    tools = await McpToolSpec(client=client).to_tool_list_async()
    agent = FunctionAgent(tools=tools, llm=OpenAI(model="gpt-5"))
    print(await agent.run("Call get_coverage, then get_projections for NBA, view compact, limit 5."))

asyncio.run(main())
```

[Full LlamaIndex guide](https://underdogapi.com/use-with-llamaindex)

### Other clients

- [ChatGPT](https://underdogapi.com/use-with-chatgpt): ChatGPT cannot send a custom API key to an MCP server: connect https://underdogapi.com/api/mcp with no authentication for the keyless search, fetch and demo tools, paste a board you exported, or use a GPT Action with your key.
- [Grok](https://underdogapi.com/use-with-grok): Point Grok at https://underdogapi.com/api/mcp: add [mcp_servers.underdog] to ~/.grok/config.toml with an Authorization header, or pass it as a remote mcp tool with headers in the xAI Responses API.
- [Lovable](https://underdogapi.com/use-with-lovable): In Lovable, build the app to call the Underdog REST API from a server function with your key stored as a secret; never put the key in browser code.

## Tools

| Tool | What it returns |
| --- | --- |
| get_coverage | Start here: every league on the board now, offer counts and stats |
| get_projections | Current lines with Higher and Lower payout multipliers |
| get_multipliers | Boosted and discounted sides on the current board |
| get_alternates | Alternate rungs for one line, with side prices |
| get_line_history | Every recorded change to one line, oldest first |
| get_changes | New, moved, repriced, pulled and restored lines across the board |
| get_board_at | The board at a past instant, for backtests |
| get_results | Lines graded against final box scores |
| get_hit_rates | How often a player has gone over, per stat |
| get_game_logs | Player box scores per game |
| get_team_stats / get_opponent_stats | Team context and what a team allows |
| get_training_set | One flat graded row per line for prop models |
| get_payouts | Standard, Flex and Streaks payout tables with break-evens |
| find_players / get_fixtures / get_injuries | Player ids, games and injury reports |
| search / fetch | Public Underdog pages, no key needed |
| get_demo_projections | Fictional sample rows, no key needed |

## Things to ask once it is connected

- What are the boosted Underdog NBA lines tonight, and what does each side pay?
- Show how LeBron James's points line has moved today on Underdog.
- Which NFL receivers have gone over their receiving yards line in at least 4 of their last 5 graded games?

## Questions

Is there an Underdog Fantasy MCP server?

Yes. Underdog API runs one at https://underdogapi.com/api/mcp. Underdog Fantasy itself does not publish an MCP server or a public API.

How do I add the Underdog MCP server to Claude?

In Claude Code, add an http server named underdog with url https://underdogapi.com/api/mcp and an Authorization: Bearer header to .mcp.json. In Claude web or desktop, add the URL as a custom connector; it connects without a key and runs the search, fetch and demo tools.

Does it work with ChatGPT?

Yes, for the keyless tools: add https://underdogapi.com/api/mcp in ChatGPT as a custom MCP server with no authentication. ChatGPT cannot send a custom API key header, so for live keyed data use a GPT Action with your key or a client that sends headers.

Does the MCP server cost extra?

No. It uses the same key and monthly credits as the REST API, including the Free plan with 100 credits a month.

Can the agent place Underdog entries?

No. Every tool is read-only data. Nothing can place an entry or touch a fantasy account.

[Agents **Step-by-step guide per client** *Every supported agent.*](https://underdogapi.com/agents) [Overview **Underdog Fantasy API options** *Official, scrapers or hosted.*](https://underdogapi.com/underdog-fantasy-api) [How-to **Underdog projections in code** *Python, JavaScript, CSV.*](https://underdogapi.com/how-to-get-underdog-projections) [For agents **agents.md** *Let an agent request a key.*](https://underdogapi.com/agents.md)

Underdog API is an independent data service. It is not affiliated with, endorsed by or operated by Underdog Fantasy or any company named on this page.

## References

- [Model Context Protocol specification](https://modelcontextprotocol.io/specification)
- [Underdog API reference](https://underdogapi.com/docs)
- [agents.md for coding agents](https://underdogapi.com/agents.md)

## FAQ

### Is there a free Underdog API?

Yes. The Free plan is a real API key on the live board, not a sample: 100 credits a month, every league, separate Higher/Lower prices and the last 24 hours of line history. No card is needed.

### Is this the official Underdog Fantasy API?

No. Underdog API is an independent data service. It is not affiliated with, endorsed by or sponsored by Underdog Fantasy or Underdog Sports.

### What data does it return?

Underdog Higher/Lower lines with separate payout multipliers and availability for each side, stable market ids through line moves, alternate rungs, recorded line history, changes, graded results and coverage/status endpoints.

### How do I use it from Claude or another AI agent?

Connect the MCP server at https://underdogapi.com/api/mcp with a bearer key, or call the REST API. Agents can request a key for their user with POST /api/v1/agent/signup.

### How much does it cost after the free tier?

Developer is $49/month for 10,000 credits, Production $149/month for 50,000, Scale $499/month for 250,000. Errors and unchanged 304 responses cost zero credits.

### How fresh is the data?

Each row carries its observation time. Check /api/v1/status and /api/v1/coverage before relying on a sport or window; missing collection is reported as unavailable, never filled in.

### Does it place entries or give picks?

No. It is data only: no entries, account operations, guaranteed outcomes or betting advice.

---
Independent data service, not affiliated with Underdog Fantasy or Underdog Sports. Docs: https://underdogapi.com/docs · OpenAPI: https://underdogapi.com/openapi.json · llms.txt: https://underdogapi.com/llms.txt
