# ESPN MCP Server: live scores and sports API (`mrbridge/espn-mcp-server`) Actor

Connect Claude, ChatGPT, Cursor and other AI assistants to ESPN sports data through MCP. Get live scores, standings, box scores, play-by-play, rosters, schedules, odds, athlete stats, rankings and news across NFL, NBA, MLB, NHL, soccer, F1 and UFC, with no ESPN API key. By MrBridge (mr-bridge.com)

- **URL**: https://apify.com/mrbridge/espn-mcp-server.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** AI, MCP servers, Integrations
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 289 total users, 95 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ESPN MCP Server

**Real-Time Sports Data for Claude Desktop, Claude Code, ChatGPT, Codex & MCP-Compatible Assistants**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00C7B7?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/mrbridge/espn-mcp-server)
[![MCP Protocol](https://img.shields.io/badge/MCP-Protocol-5A67D8?style=for-the-badge)](https://modelcontextprotocol.io)
[![ESPN](https://img.shields.io/badge/ESPN-Sports-D00000?style=for-the-badge\&logo=espn\&logoColor=white)](https://www.espn.com)

[![Tools](https://img.shields.io/badge/Tools-ESPN-blue?style=flat-square)](#what-tools-are-available)
[![Leagues](https://img.shields.io/badge/Leagues-25%2B-green?style=flat-square)](#which-sports-and-leagues-are-supported)

***

### What does ESPN MCP Server do?

ESPN MCP Server connects AI assistants like Claude Code, Claude Desktop and ChatGPT directly to ESPN's real-time sports data. It exposes a suite of specialized tools covering scores, standings, team info, rosters, schedules, detailed game analysis, betting odds, athlete profiles, rankings, news and live scoreboards, all through natural language prompts.

Instead of opening ESPN.com and navigating multiple pages, you ask your AI assistant: "What were last night's NBA scores?" or "Give me the full boxscore for the Lakers game." The MCP server fetches the data, formats it for AI consumption, and returns structured results. No ESPN API key is required.

For whole seasons in a dataset rather than live questions, use the [ESPN data scraper for boxscores and odds](https://apify.com/mrbridge/espn-sports-data-scraper).

| Without MCP | With ESPN MCP Server |
| --- | --- |
| Open ESPN.com, search for scores | Just ask Claude |
| Navigate multiple pages for stats | "Who won last night's NBA games?" |
| Compare tabs for game details | "Give me the full boxscore for the Lakers game" |
| Manually check odds on betting sites | "What are the odds for tonight's NFL games?" |
| Search for player career stats | "Show me LeBron's game log and season stats" |
| Browse different leagues separately | "Compare Premier League and La Liga standings" |

**One prompt. Every major league. Real-time data.**

**No ESPN API key required.** Connect your AI assistant once, then ask about any league it covers.

***

### Quick Start: connect in 2 minutes

#### Step 1: Sign in to Apify

Sign in to your Apify account. Claude Desktop uses this account when you connect the server. If you use Claude Code, ChatGPT, Codex, Cursor, Windsurf or VS Code, also copy your API token from [Apify Console → Settings → Integrations](https://console.apify.com/settings/integrations).

#### Step 2: Add the connector in Claude Desktop

In **Claude Desktop**, go to **Settings → Connectors → Add custom connector**, name it `ESPN`, and paste this into **Remote MCP server URL**:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp
```

Leave **Advanced settings** empty. Claude Desktop signs in to Apify for you, so the token from Step 1 is only needed by the other clients.

On **Claude Code**, **ChatGPT**, **Codex**, **Cursor**, **Windsurf** or **VS Code**, skip this step: each has its own section below.

#### Step 3: Connect and allow the tools

Click **Connect** next to the ESPN connector. Your browser opens Apify, where you choose your account and click **Allow Access**. Then click the connector to open **Tools permissions** and set it to **Always allow**.

#### Step 4: Start asking

> "What are today's NBA scores?"

That's it. The ESPN tools appear in that conversation once the connector is enabled.

***

### One endpoint, authentication per client

Every client talks to the same Streamable HTTP endpoint:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp
```

What changes from client to client is how your Apify account is proven:

- **Apify sign-in:** Claude Desktop opens Apify in your browser and you approve access once. No token is pasted or stored in the connector.
- **Bearer token:** ChatGPT receives your Apify token in the field labelled **Bearer Token env var**. Claude Code and Codex read the token from `APIFY_TOKEN`.
- **URL fallback:** append `?token=YOUR_APIFY_TOKEN` to the endpoint. The existing Cursor, Windsurf and VS Code sections use this fallback.

A URL carrying `?token=` is a credential. Keep it out of commits, screenshots, shared terminal output and recordings.

***

### What can ESPN MCP Server do?

- **MCP tools:** scores, standings, teams, rosters, schedules, news, game summaries, odds, athlete profiles, rankings, search, and live scoreboards
- **25+ leagues across 9 sports:** NFL, NBA, MLB, NHL, WNBA, College Football/Basketball, Premier League, La Liga, Bundesliga, Serie A, Champions League, MLS, UFC, PGA, F1, NASCAR, ATP, WTA, and more
- **No ESPN API key:** uses ESPN's public data endpoints, no separate registration required
- **On-demand Standby server:** wakes on the first request and sleeps again after a period of inactivity
- **Smart caching:** fixed cache lifetimes per data type, listed under [Standby only, no batch runs](#standby-only-no-batch-runs)
- **LLM-optimized:** formatted text responses designed to minimize token usage while preserving all important data

***

### What can you ask your AI assistant?

#### Live scores & game day

> "What are today's NBA scores?"

> "Is there a Monday Night Football game tonight? What's the score?"

> "Show me all Premier League matches this weekend"

#### Deep game analysis

> "Give me the full boxscore and player stats for last night's Lakers vs Celtics game"

> "Who were the top performers in yesterday's NFL games?"

#### Team intelligence

> "Show me the current NFL standings with win-loss records"

> "What's the Golden State Warriors roster? Who are their key players?"

> "What's the Lakers schedule for the rest of the season?"

#### Player research

> "Show me LeBron James' career stats and this season's game log"

> "Compare Patrick Mahomes' splits at home vs away this season"

#### Betting & odds

> "What are the betting odds for tonight's NBA games? Show me the spread and moneyline"

> "What was the over/under for the Super Bowl?"

#### News & rankings

> "What's the latest NFL news?"

> "Show me the current AP Top 25 college football rankings"

> "Get the ATP tennis rankings"

***

### What tools are available?

> **Changed in this release:** Game dates and times are now rendered using US Eastern time by default instead of UTC. Outputs containing a clock time include the timezone, such as `7:30 PM EST`. Pass `timezone` to use another IANA timezone.

Once connected, your AI assistant can use these tools:

| Tool | Description | Example |
| --- | --- | --- |
| `espn_scoreboard` | Live and recent scores for any sport/league | Today's NBA scores, yesterday's MLB results |
| `espn_standings` | Current league standings with W/L records | NFL division standings, Premier League table |
| `espn_teams` | List all teams or get detailed team info | All NBA teams, Lakers team details |
| `espn_team_roster` | Full team roster with player details | Current Warriors roster with positions |
| `espn_team_schedule` | Team game schedule (past & upcoming) | Remaining Celtics schedule |
| `espn_news` | Latest sports news headlines and articles | Top NFL headlines this week |
| `espn_game_summary` | **Most detailed:** full boxscore, player stats, venue, officials, attendance, leaders, scoring summary | Full breakdown of last night's game |
| `espn_game_odds` | Betting odds from multiple providers (Consensus, DraftKings, Caesars, Bet365) | Tonight's spread and over/under |
| `espn_athletes` | Athlete profiles, game logs, splits, career stats | LeBron's season averages and game log |
| `espn_rankings` | College, UFC, and tennis rankings | AP Top 25, UFC pound-for-pound |
| `espn_search` | Search ESPN for players, teams, and leagues | Find a player by name |
| `espn_live_scoreboard` | CDN-optimized live scoreboard with real-time updates | Live scores right now |
| `espn_play_by_play` | Play-by-play for a game, filterable by period or last N plays | Every play of the 4th quarter |

***

### About the MrBridge MCP fleet

Maintained by **MrBridge**. Full details on the [ESPN MCP server page](https://mr-bridge.com/solutions/espn-mcp-server), or see [all MrBridge MCP servers](https://mr-bridge.com/mcp-servers). New to the protocol? Start with [What is MCP and why it matters](https://mr-bridge.com/articles/what-is-mcp-model-context-protocol).

### Which sports and leagues are supported?

| Sport | Leagues | Codes |
|-------|---------|-------|
| **Football** | NFL, College Football | `football/nfl`, `football/college-football` |
| **Basketball** | NBA, WNBA, Men's College, Women's College | `basketball/nba`, `basketball/wnba`, `basketball/mens-college-basketball` |
| **Baseball** | MLB | `baseball/mlb` |
| **Hockey** | NHL | `hockey/nhl` |
| **Soccer** | Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, MLS | `soccer/eng.1`, `soccer/esp.1`, `soccer/ger.1`, `soccer/ita.1`, `soccer/fra.1`, `soccer/uefa.champions`, `soccer/usa.1` |
| **MMA** | UFC | `mma/ufc` |
| **Golf** | PGA Tour, LPGA | `golf/pga`, `golf/lpga` |
| **Racing** | Formula 1, NASCAR | `racing/f1`, `racing/nascar-premier` |
| **Tennis** | ATP, WTA | `tennis/atp`, `tennis/wta` |

Use these codes in the `sport` and `league` parameters when calling tools.

***

### Connect from Claude Desktop

Claude Desktop reaches remote MCP servers natively. There is no config file to edit, no local bridge to install, and no token to paste.

1. Open **Settings → Connectors**
2. Click **Add custom connector**
3. Name it `ESPN`
4. Paste this into **Remote MCP server URL**:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp
```

5. Leave the OAuth fields under **Advanced settings** empty, and add the connector
6. Click **Connect** next to ESPN. Your browser opens Apify, where you choose the account to connect and click **Allow Access**
7. Click the ESPN connector to open **Tools permissions**, then set the top dropdown to **Always allow** so each tool stops asking

Claude Desktop authenticates through your Apify sign-in, which is why the URL carries no token. Test with: "What are today's NBA scores?"

Anthropic documents the flow in [Getting started with custom connectors](https://support.anthropic.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp) and [Building custom connectors via remote MCP servers](https://support.anthropic.com/en/articles/11503834-building-custom-connectors-via-remote-mcp-servers).

***

### Connect from Claude Code

Export your token, then add the server from your terminal:

```bash
export APIFY_TOKEN="YOUR_APIFY_TOKEN"

claude mcp add --transport http --scope user espn \
  "https://mrbridge--espn-mcp-server.apify.actor/mcp" \
  --header 'Authorization: Bearer ${APIFY_TOKEN}'
```

Two details are deliberate. `--scope user` makes ESPN available in every project you open, where the default local scope would tie it to the directory you are standing in. The single quotes keep `${APIFY_TOKEN}` literal in Claude Code's configuration. Claude Code resolves it at connection time, so the token value is not written to `.claude.json`.

Set `APIFY_TOKEN` through your shell or secret manager. If you paste the token into an `export` command, your shell may retain it in its history.

Check the connection:

```bash
claude mcp get espn
```

A working server reports `✔ Connected`. Inside Claude Code, `/mcp` opens the server panel and lists the ESPN tools.

Claude Code asks before each tool call. To approve the whole server once, run `/permissions` and add:

```
mcp__espn__*
```

The permission pattern reuses the server name exactly as you registered it, so a server added as `espn` is allowed as `mcp__espn__*`, lowercase.

Reference: [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp).

***

### Connect from ChatGPT

1. Open **Integrations**, then **Plugins**, then click **Add MCP Server**
2. In the **Connect to a custom MCP** panel, enter `ESPN` as the **Name**
3. Set **Type** to **Streamable HTTP**. Without it the connection is not created
4. Enter the URL:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp
```

5. Enter your Apify API token in **Bearer Token env var**
6. Leave **Headers** empty
7. Click **Save** at the bottom

The server then appears in the **MCP** tab, ready to call from a conversation.

This option is available when your ChatGPT plan and workspace expose Integrations and Plugins.

Then ask:

> "Can you use the ESPN MCP server to show the latest completed WNBA games?"

***

### Connect from Codex

Codex reads the token from an environment variable, so the credential never reaches a config file:

```bash
export APIFY_TOKEN="YOUR_APIFY_TOKEN"

codex mcp add espn \
  --url "https://mrbridge--espn-mcp-server.apify.actor/mcp" \
  --bearer-token-env-var APIFY_TOKEN
```

Check the result:

```bash
codex mcp list
```

The `espn` row shows `Bearer token` as its authentication method. Inside Codex, `/mcp` shows the active MCP servers.

The same server written directly in `~/.codex/config.toml`:

```toml
[mcp_servers.espn]
url = "https://mrbridge--espn-mcp-server.apify.actor/mcp"
bearer_token_env_var = "APIFY_TOKEN"
```

No stdio bridge is required.

Reference: [Codex MCP documentation](https://developers.openai.com/codex/mcp).

***

### Connect from Cursor IDE

Add to your Cursor MCP settings (`.cursor/mcp.json` in your project or global config):

```json
{
  "mcpServers": {
    "ESPN": {
      "url": "https://mrbridge--espn-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

Then ask Cursor's AI: "What are tonight's NBA scores?"

***

### Connect from Windsurf

In Windsurf, go to **Settings → MCP** and add a new server with the URL:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

All ESPN tools become available in Windsurf's AI assistant.

***

### Connect from VS Code (Copilot, Cline, Continue)

#### GitHub Copilot (VS Code)

Add to your `.vscode/mcp.json`:

```json
{
  "servers": {
    "ESPN": {
      "type": "http",
      "url": "https://mrbridge--espn-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

#### Cline Extension

In Cline settings, go to **MCP Servers → Remote Servers** and add:

```
https://mrbridge--espn-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

#### Continue Extension

Add to your `.continue/config.yaml`:

```yaml
mcpServers:
  - name: ESPN
    url: https://mrbridge--espn-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

***

### Standby only, no batch runs

This Actor is designed for remote MCP connections in Standby mode. Conventional Actor runs, scheduled batch runs and Dataset-based integrations are not supported.

The server starts automatically on the first request and stays warm for 300 seconds after the latest request. The first connection after inactivity may take several seconds. Subsequent calls are faster while the server remains warm.

A run started from the Console, the API or an Example page returns no sports data. It ends within seconds and bills no tool event. Its status message names the endpoint, and its log lists the connection steps.

No Actor Input is required by the MCP server. Apify requires these published Example pages to select at least one input field, so the legacy Cache TTL field remains visible as a display-only compatibility field. The server does not read that value.

Smart caching: 60 seconds for live scores, 5 minutes for standings and schedules, 15 minutes for teams and rosters, and 24 hours for rankings.

***

### How does it work?

```
Claude Code / Claude Desktop / ChatGPT
        |
        |  MCP (Streamable HTTP)
        v
+-----------------------------+
|   ESPN MCP Server (Apify)   |
|   +---------------------+   |
|   |  MCP Tools           |   |
|   |  4-tier TTL cache    |   |
|   |  Retry + Backoff     |   |
|   +---------------------+   |
+-------------+---------------+
              |  HTTP GET (JSON)
              v
        ESPN Public API
     (site, web, CDN endpoints)
```

**Key design decisions:**

- **Stateless transport:** each request gets a fresh MCP server instance, so a Standby container restart loses no session
- **Concise formatting:** no raw JSON dumps, structured text optimized for LLM consumption
- **Graceful errors:** every tool returns human-readable error messages and never crashes

***

### Is my data safe?

- **No ESPN account required:** the server uses ESPN's public data endpoints. No API key, no registration
- **No data stored:** all data is fetched in real time and never persisted
- **Read-only:** the server only reads public sports data. No write operations
- **Apify token:** only used for MCP authentication with Apify's platform, never shared with ESPN

***

### How much does it cost?

This MCP server uses Apify's pay-per-event pricing. Two things are billed to you:

- **Tool calls**, priced per event. Current prices are on the [Pricing tab](https://apify.com/mrbridge/espn-mcp-server/pricing), which is always up to date.
- **Platform usage** for the running container. In Standby mode the server stays warm after a request and shuts down after 300 seconds of inactivity. That warm time is billed as platform usage, on top of the tool-call events.

#### What is and is not charged

Charged for a completed query, including a no-results response. Calls rejected during input validation or by ESPN, and technical failures, are not charged.

A no-results answer is a delivered service: the question was valid, the request was made, and "no games scheduled today" is the correct answer. A rejected identifier or an ESPN outage is not.

#### Spending caps

One run-wide dollar spending cap applies. Whether another call fits depends on that call's event price, so a cheaper call may still be charged after a more expensive one is refused. When another event of the same type no longer fits, the billed response ends with this warning:

> ⚠️ Cost cap reached. Further tool calls in this run may be blocked.

[Start with $5 free credits](https://apify.com/mrbridge/espn-mcp-server).

***

### Troubleshooting

| Problem | Solution |
| --- | --- |
| "Tools not showing up" | Verify your Apify token is correct. Check that the URL includes `/mcp` path |
| "Needs authentication" or 401 | The token is missing or wrong. On URL-only clients, check that `?token=` carries the whole token. On Codex, check that the environment variable named by `--bearer-token-env-var` is exported in the shell that launches Codex |
| "Empty results" | Some endpoints require specific sport/league codes. Check the [Supported Sports](#which-sports-and-leagues-are-supported) table |
| "Connection timeout" | This is the cold start. The server wakes on the first request after inactivity, which can take several seconds. Retry once |
| "Game summary returns error" | Game summaries require a valid `eventId`. Use `espn_scoreboard` first to find game IDs |
| "I started a run and got no data" | Runs started from the Console, the API or an Example page only return the connection details. Connect your AI client to the MCP endpoint instead |

***

### More sports data tools

- [bulk ESPN sports data](https://apify.com/mrbridge/espn-sports-data-scraper): whole seasons of scores, boxscores, odds and player gamelogs as a flat dataset.
- [German football MCP server](https://apify.com/mrbridge/german-football-mcp): Bundesliga tables, fixtures, results and top scorers down to the Regionalliga, women's football included.
- [free news API for AI](https://apify.com/mrbridge/latest-news-mcp-server): global news in 65+ languages from 22 public APIs, plus markets, weather and trends, no API key.

### FAQ

#### What is an ESPN MCP Server?

An MCP (Model Context Protocol) server that bridges AI assistants and ESPN sports data. It exposes tools that AI assistants can call to retrieve scores, standings, stats, news, odds, and more, all through natural language prompts.

#### Do I need an ESPN account or API key?

No. This server uses ESPN's publicly available data endpoints. No ESPN account, no API key, no registration. You only need an Apify account (free tier available).

#### Does this work with ChatGPT, Codex, Cursor, or VS Code?

Yes. Clients that support remote Streamable HTTP and one of the authentication methods above can connect. Claude Desktop, Claude Code, ChatGPT and Codex each have their own connection section above, and configuration snippets for Cursor, Windsurf and VS Code follow them.

#### How real-time is the data?

Smart caching: 60 seconds for live scores, 5 minutes for standings and schedules, 15 minutes for teams and rosters, and 24 hours for rankings. For live games, you get near-real-time updates.

#### Which sports are supported?

25+ leagues across football (NFL, college), basketball (NBA, WNBA, college), baseball (MLB), hockey (NHL), soccer (Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, MLS), MMA (UFC), golf (PGA), racing (F1, NASCAR), and tennis (ATP, WTA).

#### Can I get betting odds?

Yes. The `espn_game_odds` tool returns odds from multiple providers including Consensus, DraftKings, Caesars, and Bet365: spreads, moneylines, over/unders, and win percentages.

#### Is my data secure?

This server only reads publicly available ESPN data. No personal accounts are accessed. Your Apify API token is used solely for authentication with Apify's platform.

#### How much does it cost?

You pay per tool call, plus the platform usage of the running container. See the full [pricing breakdown](#how-much-does-it-cost).

#### Can I use it for fantasy sports research?

Absolutely. Use `espn_athletes` for player stats, game logs, and splits. Use `espn_team_schedule` to check upcoming matchups. Use `espn_game_summary` for detailed performance data. Ideal for weekly fantasy lineup decisions.

#### How do I find game IDs for the summary tool?

Use `espn_scoreboard` first to get today's games. Each game includes an `eventId`. You can also find game IDs in ESPN URLs: `espn.com/nba/game/_/gameId/401584793` → eventId is `401584793`.

***

### What does the output look like?

Here's a sample response from the `espn_scoreboard` tool for NBA scores:

```
NBA Scoreboard, Mar 14, 2026

Boston Celtics 112 - 105 Milwaukee Bucks (Final)
  Top: J. Tatum 32pts/8reb/6ast | G. Antetokounmpo 28pts/12reb/5ast

Los Angeles Lakers 98 - 101 Golden State Warriors (Final)
  Top: L. James 25pts/7reb/9ast | S. Curry 31pts/4reb/6ast

Dallas Mavericks 119 - 115 Phoenix Suns (Final/OT)
  Top: L. Doncic 38pts/10reb/8ast | K. Durant 35pts/6reb/4ast
```

And a sample from `espn_game_summary` with detailed boxscore:

```
Boston Celtics 112 - 105 Milwaukee Bucks
Venue: TD Garden, Boston, MA | Attendance: 19,156

SCORING BY QUARTER:
  BOS: 28 | 30 | 25 | 29 = 112
  MIL: 22 | 31 | 27 | 25 = 105

LEADERS:
  BOS | J. Tatum: 32pts 8reb 6ast | J. Brown: 24pts 5reb 3ast
  MIL | G. Antetokounmpo: 28pts 12reb 5ast | D. Lillard: 22pts 3reb 8ast
```

### Changelog

Release notes are available in the Actor's Changelog.

***

### Resources

- [Apify MCP Documentation](https://docs.apify.com/integrations/mcp)
- [MCP Protocol Specification](https://modelcontextprotocol.io)
- [Get your Apify API Token](https://console.apify.com/settings/integrations)
- [Claude custom connectors](https://support.anthropic.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp)
- [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp)
- [Codex MCP documentation](https://developers.openai.com/codex/mcp)
- [Report a problem or ask a question](https://apify.com/mrbridge/espn-mcp-server/issues/open)

***

**Built for sports fans who want AI to do the research.**

# Changelog

This Actor's version history is a separate document: https://apify.com/mrbridge/espn-mcp-server/changelog.md

# Actor input Schema

## `cacheTtlSeconds` (type: `integer`):

This compatibility field keeps published Example pages available. The MCP server does not read it and uses fixed cache durations by data type.

## Actor input object example

```json
{
  "cacheTtlSeconds": 300
}
```

# Actor output Schema

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/espn-mcp-server").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/espn-mcp-server").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call mrbridge/espn-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/espn-mcp-server"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OS9xgGMTqfof7z05J/builds/aVshu1egOIChJank8/openapi.json