ESPN MCP server for AI agents
Let Claude, ChatGPT or your own agent read and act on ESPN: 35 typed functions through one MCP server. No ESPN API key needed.
- Site
- espn.com
- Functions
- 35
- Sign-in
- For account actions
- Works with
- MCP, HTTP, Node, Python
Connect
An MCP server for ESPN alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.
https://api.bowmark.ai/mcp/site/espnOne MCP server for ESPN and every other site Bowmark covers. Your agent looks up what it needs and calls it.
https://api.bowmark.ai/mcpSet it up in your clientBoth need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.
Functions
Open a function to see its arguments, what it returns and how to call it.
draftPicksA league's draft pick by pick.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", "nhl".Yes seasonnumberDraft year; default ESPN's current draft.No roundnumberOnly this round.No teamstringOnly this team's picks, by abbreviation, name or nickname.No Returns
DraftPicksResultinterface DraftPick { round: number; pick: number; overall: number; status: string; // the site's own labels, e.g. "SELECTION_MADE", read the values off a result, never guess one from prose traded: boolean; tradeNote: string | null; team: { id: string; abbreviation: string; name: string } | null; athlete: { id: string; name: string; position: string | null; school: string | null; height: string | null; weight: string | null; url: string | null; } | null; } interface DraftPicksResult { league: string; season: number | null; name: string | null; status: string | null; // the site's own labels, read the values off a result, never guess one from prose picks: DraftPick[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/draftPicksCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.draftPicks({ league: "nfl", season: 2026, round: 1 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.draftPicks({"league": "nfl", "season": 2026, "round": 1}))curl -X POST https://api.bowmark.ai/v1/sites/espn/draftPicks \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","season":2026,"round":1}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.draftPicks({ league: "nfl", season: 2026, round: 1 });fantasyPlayersESPN Fantasy's public player board for fantasy football, baseball, basketball or hockey.Arguments
Name Type Required sportstring"football", "baseball", "basketball" or "hockey".Yes seasonnumberSeason year, e.g. 2026.No limitnumberHow many players to return, ranked by percent-rostered.No Returns
FantasyPlayersResultinterface FantasyPlayer { id: number; fullName: string; position: string | null; // ESPN's own position abbreviation, when the id is known proTeamId: number | null; // ESPN fantasy's own numeric pro-team id, not resolved to a name injuryStatus: string | null; percentOwned: number | null; percentStarted: number | null; averageDraftPosition: number | null; positionRank: number | null; // this season's PPR position rank, when ESPN publishes one seasonPoints: number | null; // this season's actual fantasy points so far, null where ESPN publishes none (basketball, hockey, most baseball: category-scored boards) projectedPoints: number | null; // this season's full-season projected fantasy points } interface FantasyPlayersResult { sport: string; season: number; players: FantasyPlayer[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/fantasyPlayersCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.fantasyPlayers({ sport: "football", limit: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.fantasyPlayers({"sport": "football", "limit": 5}))curl -X POST https://api.bowmark.ai/v1/sites/espn/fantasyPlayers \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"sport":"football","limit":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.fantasyPlayers({ sport: "football", limit: 5 });getArticleThe full text of one ESPN story.Arguments
Name Type Required articleIdstringArticle id from news(), or an espn.com story URL carrying /story/_/id/<id>/.Yes Returns
Articleinterface ArticleImage { url: string; caption: string | null; } interface Article { id: string; headline: string; description: string | null; byline: string | null; published: string | null; updated: string | null; paragraphs: string[]; // body paragraphs, HTML markup stripped images: ArticleImage[]; teams: string[]; players: string[]; url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getArticleCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getArticle({ articleId: "50302002" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getArticle({"articleId": "50302002"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getArticle \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"articleId":"50302002"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getArticle({ articleId: "50302002" });getFantasyLeagueOne ESPN fantasy league, settings, standings, this week's matchups and every team with its owner's display name.Arguments
Name Type Required sportstring"football", "baseball", "basketball" or "hockey".Yes leagueIdstring | numberThe league id from a fantasy.espn.com URL, or the URL itself.Yes seasonnumberSeason year, e.g. 2026.No Returns
FantasyLeagueResultinterface FantasyLeagueTeam { id: number; name: string; abbreviation: string | null; ownerName: string | null; // the owning member's displayName, when resolvable wins: number; losses: number; ties: number; pointsFor: number; pointsAgainst: number; playoffSeed: number | null; } interface FantasyLeagueMatchup { matchupPeriodId: number; homeTeamId: number | null; homeScore: number | null; awayTeamId: number | null; awayScore: number | null; winner: string | null; // "HOME", "AWAY" or "UNDECIDED", the site's own label } interface FantasyLeagueResult { leagueId: string; season: number; name: string | null; size: number | null; isPublic: boolean | null; currentMatchupPeriod: number | null; teams: FantasyLeagueTeam[]; thisWeekMatchups: FantasyLeagueMatchup[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getFantasyLeagueCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getFantasyLeague({ sport: "football", leagueId: "1249" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getFantasyLeague({"sport": "football", "leagueId": "1249"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getFantasyLeague \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"sport":"football","leagueId":"1249"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getFantasyLeague({ sport: "football", leagueId: "1249" });getFantasyTeamOne team in an ESPN fantasy league.Arguments
Name Type Required sportstring"football", "baseball", "basketball" or "hockey".Yes leagueIdstring | numberThe league id from a fantasy.espn.com URL, or the URL itself.Yes teamIdstring | numberThe team id inside that league (getFantasyLeague's teams[].id), or a URL carrying teamId=.Yes seasonnumberSeason year, e.g. 2026.No Returns
FantasyTeamResultinterface FantasyRosterPlayer { playerId: number; fullName: string; lineupSlotId: number; // ESPN fantasy's numeric lineup slot id lineupSlot: string | null; // football only: "QB", "RB", "WR", "TE", "OP", "FLEX", "D/ST", "K", "Bench", "IR" position: string | null; // football only: "QB", "RB", "WR", "TE", "K", "D/ST" proTeamId: number | null; injuryStatus: string | null; projectedPoints: number | null; // this scoring period actualPoints: number | null; // this scoring period; null until games are played } interface FantasyTeamResult { leagueId: string; season: number; scoringPeriodId: number | null; teamId: number; name: string; abbreviation: string | null; ownerName: string | null; wins: number; losses: number; ties: number; pointsFor: number; pointsAgainst: number; playoffSeed: number | null; roster: FantasyRosterPlayer[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getFantasyTeamCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getFantasyTeam({ sport: "football", leagueId: "1249", teamId: 4 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getFantasyTeam({"sport": "football", "leagueId": "1249", "teamId": 4}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getFantasyTeam \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"sport":"football","leagueId":"1249","teamId":4}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getFantasyTeam({ sport: "football", leagueId: "1249", teamId: 4 });getGameOne game in full, with score by period, every player's box-score line, team stats, scoring plays, play-by-play, game leaders, venue, attendance…Arguments
Name Type Required eventIdstringEvent id from scoreboard or teamSchedule.Yes leaguestringLeague slug (required to construct the API URL).Yes Returns
GameDetailinterface GameDetail { eventId: string; league: string; status: string; // the site's own labels, read the values off a result, never guess one from prose homeTeam: { name: string; abbreviation: string; id: string; score: number | null; }; awayTeam: { name: string; abbreviation: string; id: string; score: number | null; }; dateTime: string; venue: string | null; broadcasts: string[]; period: number | null; timeRemaining: string | null; attendance: number | null; weather: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getGameCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getGame({ eventId: "401872981", league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getGame({"eventId": "401872981", "league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getGame \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"eventId":"401872981","league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getGame({ eventId: "401872981", league: "nfl" });getPlayerOne player's page, team, position, jersey, age, height, weight, college, status and headshot.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes athleteIdstringESPN athlete id, from search's or teamRoster's results.Yes Returns
Playerinterface PlayerTeam { id: string; abbreviation: string; name: string; } interface Player { id: string; fullName: string; jersey: string | null; position: string | null; positionName: string | null; team: PlayerTeam | null; age: number | null; displayHeight: string | null; displayWeight: string | null; college: string | null; status: string | null; // the site's own labels, read the values off a result, never guess one from prose headshot: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getPlayerCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getPlayer({ league: "nfl", athleteId: "3139477" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getPlayer({"league": "nfl", "athleteId": "3139477"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getPlayer \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","athleteId":"3139477"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getPlayer({ league: "nfl", athleteId: "3139477" });getTeamOne team's page header, record, standing in its division, next game, coach, venue and links, by name, abbreviation or ESPN id.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes teamstringTeam abbreviation, name, or nickname (e.g. "ARI", "Cardinals", "Arizona Cardinals").Yes Returns
GetTeamResultinterface TeamNextGame { eventId: string; dateTime: string; shortName: string; isHome: boolean; opponent: { id: string; abbreviation: string; name: string } | null; } interface TeamHeader { id: string; abbreviation: string; name: string; location: string; nickname: string; color: string | null; alternateColor: string | null; standingSummary: string | null; // the site's own label, e.g. "3rd in NFC West" wins: number | null; losses: number | null; ties: number | null; venue: string | null; logo: string | null; nextGame: TeamNextGame | null; } interface GetTeamResult { league: string; team: TeamHeader; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/getTeamCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.getTeam({ league: "nfl", team: "ARI" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.getTeam({"league": "nfl", "team": "ARI"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/getTeam \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","team":"ARI"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.getTeam({ league: "nfl", team: "ARI" });injuriesReads a league's injury report the way ESPN's own /nfl/injuries page does.Arguments
Name Type Required league"nfl" | "nba" | "wnba" | "mlb" | "nhl"Default "nfl".No teamstringOne team, by name or abbreviation: "Chiefs", "Kansas City Chiefs", "KC".No Returns
EspnInjuryReportinterface EspnInjury { team: string; teamAbbreviation: string; player: string; position: string | null; status: string; // "Questionable", "Out", "Injured Reserve" injury: string | null; returnDate: string | null; note: string | null; detail: string | null; updated: string; playerUrl: string | null; } interface EspnInjuryReport { league: "nfl" | "nba" | "wnba" | "mlb" | "nhl"; season: string | null; updated: string | null; injuries: EspnInjury[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/injuriesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.injuries();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.injuries())curl -X POST https://api.bowmark.ai/v1/sites/espn/injuries \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.injuries();listFavoritesThe CALLER's My ESPN favourites.Arguments
None.
Returns
ListFavoritesResultinterface EspnFavorite { id: string; // ESPN's preference id kind: string | null; kindName: string | null; name: string | null; url: string | null; sortOrder: number | null; hidden: boolean; deletable: boolean | null; } interface ListFavoritesResult { favorites: EspnFavorite[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/listFavoritesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.listFavorites();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.listFavorites())curl -X POST https://api.bowmark.ai/v1/sites/espn/listFavorites \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.listFavorites();listLeaguesEvery sport ESPN's core API tracks (call with no arguments), or every league slug under one sport (pass sport).Arguments
Name Type Required sportstringNarrow to one sport's leagues, by the slug listLeagues() (no args) returns.No Returns
EspnLeagueCataloginterface EspnSport { slug: string; // "football", "soccer", "basketball", this function's own sport arg name: string; // "Football", "Soccer", "Basketball" } interface EspnLeagueCatalog { sport: string | null; // echoes the argument sports: EspnSport[] | null; // populated only when sport was omitted leagues: string[] | null; // populated only when sport was given, e.g. "nfl", "eng.1", "usa.1" }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/listLeaguesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.listLeagues();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.listLeagues())curl -X POST https://api.bowmark.ai/v1/sites/espn/listLeagues \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.listLeagues();listMyFantasyTeamsThe CALLER's own ESPN fantasy teams across every game (football, baseball, basketball, hockey).Arguments
None.
Returns
ListMyFantasyTeamsResultinterface FantasyTeamSummary { sport: string | null; // "football", "baseball", "basketball" or "hockey" season: number; leagueId: string; leagueName: string | null; teamId: number; teamName: string | null; teamAbbreviation: string | null; } interface ListMyFantasyTeamsResult { teams: FantasyTeamSummary[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/listMyFantasyTeamsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.listMyFantasyTeams();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.listMyFantasyTeams())curl -X POST https://api.bowmark.ai/v1/sites/espn/listMyFantasyTeams \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.listMyFantasyTeams();listTeamsEvery team in a league with its ESPN id, abbreviation, name, location, colours and logo.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes Returns
ListTeamsResultinterface EspnTeam { id: string; abbreviation: string; name: string; // full display name, e.g. "Arizona Cardinals" location: string; // city or region, e.g. "Arizona" nickname: string; // e.g. "Cardinals" color: string | null; // hex, no leading "#" alternateColor: string | null; logo: string | null; } interface ListTeamsResult { league: string; teams: EspnTeam[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/listTeamsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.listTeams({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.listTeams({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/listTeams \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.listTeams({ league: "nfl" });listVideosESPN's latest highlight and analysis video clips for a league, optionally one team's.Arguments
Name Type Required leaguestringA league slug or name, e.g. "nfl", "nba", "college-football".Yes teamstringKeep only clips tagged with a team whose name contains this.No limitnumberDefault 25, max 50.No Returns
ListVideosResultinterface EspnVideo { id: string; headline: string; description: string | null; duration: number | null; // seconds published: string | null; // ISO instant thumbnail: string | null; url: string | null; // the espn.com watch page teams: string[]; players: string[]; } interface ListVideosResult { league: string; videos: EspnVideo[]; // newest first }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/listVideosCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.listVideos({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.listVideos({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/listVideos \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.listVideos({ league: "nfl" });newsThe latest ESPN headlines for a league, optionally narrowed to one team.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes teamstringNarrow to articles tagged with this team, by name or abbreviation.No Returns
NewsResultinterface NewsArticle { id: string; headline: string; description: string | null; byline: string | null; published: string | null; url: string | null; teams: string[]; // team names this article is tagged with } interface NewsResult { league: string; articles: NewsArticle[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/newsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.news({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.news({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/news \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.news({ league: "nfl" });oddsThe betting lines ESPN shows for a league's games.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", "nhl", etc.Yes gameIdstringOne game's ESPN id (from scoreboard).No Returns
OddsResultinterface OddsLine { provider: string; details: string | null; spread: number | null; overUnder: number | null; overOdds: number | null; underOdds: number | null; away: { moneyLine: number | null; spreadOdds: number | null; favorite: boolean }; home: { moneyLine: number | null; spreadOdds: number | null; favorite: boolean }; } interface GameOdds { gameId: string; name: string | null; date: string | null; lines: OddsLine[]; } interface OddsResult { league: string; games: GameOdds[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/oddsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.odds({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.odds({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/odds \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.odds({ league: "nfl" });playerGameLogOne player's game-by-game log for a season.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes athleteIdstringESPN athlete id, from search's or teamRoster's results.Yes Returns
PlayerGameLogResultinterface PlayerGameLogEntry { eventId: string; // pass to getGame for full details week: number | null; date: string | null; opponentAbbreviation: string | null; isHome: boolean | null; result: string | null; // "W" or "L", the site's own label score: string | null; stats: Record<string, string>; // keyed by ESPN's own stat name } interface PlayerGameLogResult { league: string; athleteId: string; seasonDisplayName: string | null; games: PlayerGameLogEntry[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/playerGameLogCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.playerGameLog({ league: "nfl", athleteId: "3139477" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.playerGameLog({"league": "nfl", "athleteId": "3139477"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/playerGameLog \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","athleteId":"3139477"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.playerGameLog({ league: "nfl", athleteId: "3139477" });playerStatsOne player's full statistics.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes athleteIdstringESPN athlete id, from search's or teamRoster's results.Yes Returns
PlayerStatsResultinterface PlayerSeasonStats { season: number; teamId: string | null; stats: Record<string, string>; // keyed by ESPN's own stat name, e.g. "passingYards" } interface PlayerStatCategory { name: string; // ESPN's own category key, e.g. "passing", "rushing" displayName: string; seasons: PlayerSeasonStats[]; } interface PlayerSplit { displayName: string; // "All Splits", "Home", "Away", "Wins/Ties", … stats: Record<string, string>; } interface PlayerSplitCategory { name: string; displayName: string; splits: PlayerSplit[]; } interface PlayerStatsResult { league: string; athleteId: string; careerCategories: PlayerStatCategory[]; currentSeasonSplits: PlayerSplitCategory[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/playerStatsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.playerStats({ league: "nfl", athleteId: "3139477" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.playerStats({"league": "nfl", "athleteId": "3139477"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/playerStats \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","athleteId":"3139477"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.playerStats({ league: "nfl", athleteId: "3139477" });rankingsCollege polls, the AP Top 25, the Coaches Poll and (in season) the playoff rankings for college football and men's college basketball, with rank…Arguments
Name Type Required leaguestring"college-football" (default) or "mens-college-basketball".No pollstringNarrow to one poll by name or short name, e.g. "AP".No Returns
RankingsResultinterface PollRank { rank: number; previous: number | null; trend: string; // "+1", "-2", "-" points: number | null; firstPlaceVotes: number | null; record: string | null; team: { id: string; abbreviation: string; name: string }; } interface Poll { id: string; name: string; shortName: string; week: string | null; // e.g. "Week 9" date: string | null; ranks: PollRank[]; } interface RankingsResult { league: string; season: number | null; polls: Poll[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/rankingsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.rankings({ league: "college-football" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.rankings({"league": "college-football"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/rankings \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"college-football"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.rankings({ league: "college-football" });scoreboardA league's games for today, a date, a date range or a football week.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "eng.1", etc.Yes datestringOptional: one specific date (YYYY-MM-DD format).No datesstringOptional: date range, format "YYYY-MM-DD to YYYY-MM-DD".No seasonType"preseason" | "regular" | "postseason"Optional: for football leagues only. "preseason", "regular", or "postseason".No weeknumberOptional: for football leagues only.No Returns
ScoreboardResultinterface Game { eventId: string; status: string; // the site's own labels, read the values off a result, never guess one from prose homeTeam: { name: string; abbreviation: string; id: string }; awayTeam: { name: string; abbreviation: string; id: string }; homeScore: number | null; awayScore: number | null; dateTime: string; venue: string | null; broadcasts: string[]; period: number | null; timeRemaining: string | null; } interface ScoreboardResult { league: string; games: Game[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/scoreboardCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.scoreboard({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.scoreboard({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/scoreboard \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.scoreboard({ league: "nfl" });searchESPN's own site search, players, teams, leagues and articles matching free text, each with its ESPN id and sport.Arguments
Name Type Required querystringYes Returns
SearchResultinterface SearchEntity { /** The numeric id off this entry's uid, pass to getPlayer, or use directly * against ESPN's team/league endpoints. Null when the uid carries none. */ espnId: string | null; name: string; subtitle: string | null; sport: string | null; leagueSlug: string | null; // the league slug listLeagues() would resolve url: string | null; } interface SearchArticle { id: string; headline: string; url: string | null; } interface SearchResult { query: string; players: SearchEntity[]; teams: SearchEntity[]; leagues: SearchEntity[]; articles: SearchArticle[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/searchCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.search({ query: "mahomes" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.search({"query": "mahomes"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/search \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"query":"mahomes"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.search({ query: "mahomes" });standingsA league's current standings by conference and division.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes seasonnumberOptional: season year (e.g. 2025).No Returns
StandingsResultinterface TeamStanding { name: string; abbreviation: string; id: string; wins: number; losses: number; ties: number; winPercentage: number; gamesBack: number | null; streak: string | null; homeRecord: string | null; awayRecord: string | null; pointsFor: number | null; pointsAgainst: number | null; playoffSeed: number | null; } interface Division { name: string; teams: TeamStanding[]; } interface Conference { name: string; divisions: Division[]; } interface StandingsResult { league: string; conferences: Conference[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/standingsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.standings({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.standings({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/standings \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.standings({ league: "nfl" });statLeadersA league's season leaderboard.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes categorystringNarrow to one category by key or display name, case-insensitive.No Returns
StatLeadersResultinterface StatLeaderEntry { value: number; displayValue: string; athlete: { id: string; fullName: string; position: string | null }; team: { id: string; abbreviation: string; name: string } | null; } interface StatLeaderCategory { name: string; // ESPN's own category key, e.g. "passingYards" displayName: string; leaders: StatLeaderEntry[]; } interface StatLeadersResult { league: string; categories: StatLeaderCategory[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/statLeadersCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.statLeaders({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.statLeaders({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/statLeaders \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.statLeaders({ league: "nfl" });teamDepthChartOne team's depth chart, every formation ESPN publishes (offense, base defense, special teams), each position with its athletes in depth order (1 =…Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes teamstringTeam abbreviation, name, or nickname.Yes Returns
TeamDepthChartResultinterface DepthChartAthlete { id: string; name: string; depth: number; // 1 = starter injuryStatus: string | null; // "Questionable", "Out", "Injured Reserve", or null } interface DepthChartPosition { key: string; // ESPN slot key, e.g. "qb", "wr1", "lde" abbreviation: string; name: string; athletes: DepthChartAthlete[]; } interface DepthChartFormation { id: string; name: string; // e.g. "3WR 1TE", "Base 4-3 D", "Special Teams" positions: DepthChartPosition[]; } interface TeamDepthChartResult { league: string; team: { id: string; abbreviation: string; name: string }; formations: DepthChartFormation[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/teamDepthChartCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.teamDepthChart({ league: "nfl", team: "ARI" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.teamDepthChart({"league": "nfl", "team": "ARI"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/teamDepthChart \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","team":"ARI"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.teamDepthChart({ league: "nfl", team: "ARI" });teamRosterOne team's current roster, every player with jersey number, position, age, height, weight, experience, college, status and ESPN athlete id, grouped…Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes teamstringTeam abbreviation, name, or nickname (e.g. "ARI", "Cardinals", "Arizona Cardinals").Yes Returns
TeamRosterResultinterface RosterPlayer { id: string; // ESPN athlete id, pass to getPlayer fullName: string; jersey: string | null; position: string | null; // abbreviation, e.g. "RB", "QB", "CB" positionName: string | null; age: number | null; displayHeight: string | null; displayWeight: string | null; experienceYears: number | null; college: string | null; status: string | null; // the site's own label, e.g. "Active", "Injured Reserve" } interface RosterGroup { group: string; // ESPN's own group key, e.g. "offense", "defense", "specialTeam" players: RosterPlayer[]; } interface TeamRosterResult { league: string; team: { id: string; abbreviation: string; name: string }; groups: RosterGroup[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/teamRosterCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.teamRoster({ league: "nfl", team: "ARI" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.teamRoster({"league": "nfl", "team": "ARI"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/teamRoster \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","team":"ARI"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.teamRoster({ league: "nfl", team: "ARI" });teamScheduleOne team's full season schedule.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.Yes teamstringTeam abbreviation, name, or nickname (e.g., "ARI", "Cardinals", "Arizona Cardinals").Yes seasonnumberSeason year (e.g., 2026).Yes seasonTypestringSeason type: "preseason", "regular", or "postseason" (optional, defaults to "regular").No Returns
TeamScheduleResultinterface Game { eventId: string; status: string; // the site's own labels, read the values off a result, never guess one from prose homeTeam: { name: string; abbreviation: string; id: string }; awayTeam: { name: string; abbreviation: string; id: string }; homeScore: number | null; awayScore: number | null; dateTime: string; venue: string | null; broadcasts: string[]; period: number | null; timeRemaining: string | null; } interface ScheduleGame { /** ESPN's internal event id, pass to getGame for full details */ eventId: string; /** The league being queried (e.g., "nfl", "nba") */ league: string; /** Opponent's full name (e.g., "New York Giants") */ opponent: string; /** Opponent's abbreviation (e.g., "NYG") */ opponentAbr: string; /** true if the queried team is home, false if away */ isHome: boolean; /** Game date and time in ISO 8601 format */ dateTime: string; /** Game status: "scheduled", "in progress", "final", etc. */ status: string; /** Home team score, null if not yet played */ homeScore: number | null; /** Away team score, null if not yet played */ awayScore: number | null; /** Broadcasting network(s) */ broadcasts: string[]; /** Venue name */ venue: string | null; } interface TeamScheduleResult { /** The league queried (e.g., "nfl", "nba") */ league: string; /** The team queried */ team: { id: string; abbreviation: string; name: string; }; /** Season year */ season: number; /** Season type (e.g., "regular", "postseason") */ seasonType: string; /** Games in the schedule */ games: ScheduleGame[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/teamScheduleCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.teamSchedule({ league: "nfl", team: "ARI", season: 2026 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.teamSchedule({"league": "nfl", "team": "ARI", "season": 2026}))curl -X POST https://api.bowmark.ai/v1/sites/espn/teamSchedule \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","team":"ARI","season":2026}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.teamSchedule({ league: "nfl", team: "ARI", season: 2026 });teamStatsOne team's season statistics, team totals and per-game, with its league rank in each category.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", etc.Yes teamstringTeam abbreviation, name, or nickname.Yes Returns
TeamStatsResultinterface TeamStatValue { name: string; // ESPN's own stat key, e.g. "completionPct", "rushingYards" displayName: string; value: number; displayValue: string; rank: number | null; // the team's league rank in this stat, when ESPN publishes one } interface TeamStatCategory { name: string; // ESPN's own category key, e.g. "passing", "rushing", "defensive" displayName: string; stats: TeamStatValue[]; } interface TeamStatsResult { league: string; team: { id: string; abbreviation: string; name: string }; season: number | null; categories: TeamStatCategory[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/teamStatsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.teamStats({ league: "nfl", team: "ARI" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.teamStats({"league": "nfl", "team": "ARI"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/teamStats \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl","team":"ARI"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.teamStats({ league: "nfl", team: "ARI" });transactionsA league's recent transactions.Arguments
Name Type Required leaguestringLeague slug: "nfl", "nba", "mlb", "nhl", etc.Yes teamstringNarrow to one team by abbreviation, name or nickname.No pagenumber1-based page, default 1.No limitnumberRows per page, default 25, max 100.No Returns
TransactionsResultinterface Transaction { date: string; description: string; team: { id: string; abbreviation: string; name: string } | null; } interface TransactionsResult { league: string; season: number | null; total: number; page: number; pageCount: number; transactions: Transaction[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/transactionsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.transactions({ league: "nfl" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.transactions({"league": "nfl"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/transactions \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"league":"nfl"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.transactions({ league: "nfl" });
addDropFantasyPlayerAdds a free agent to the CALLER's own ESPN fantasy team, dropping one of theirs if the roster is full, or places a waiver claim when the player is on…Arguments
Name Type Required argsAddDropFantasyPlayerArgsYes interface FantasyLeagueRef { sport: string; // "football" | "baseball" | "basketball" | "hockey" leagueId: string | number; teamId: number; // the caller's own team season?: number; scoringPeriodId?: number; } interface AddDropFantasyPlayerArgs extends FantasyLeagueRef { addPlayerId?: number; dropPlayerId?: number; }Returns
FantasyTransactionResultinterface FantasyTransactionResult { id: string | null; status: string | null; // the site's own labels, read the values off a result, never guess one from prose type: string; raw: unknown; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/addDropFantasyPlayerCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.addDropFantasyPlayer("<args>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.addDropFantasyPlayer("<args>"))curl -X POST https://api.bowmark.ai/v1/sites/espn/addDropFantasyPlayer \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":"<args>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.addDropFantasyPlayer("<args>");addFavoriteAdds a team, league or player to the CALLER's My ESPN favourites.Arguments
Name Type Required idstringESPN preference id, as listFavorites returns it.Yes kindstringType.code, "team", "league", "player", "fantasy".Yes Returns
ListFavoritesResultinterface EspnFavorite { id: string; // ESPN's preference id kind: string | null; kindName: string | null; name: string | null; url: string | null; sortOrder: number | null; hidden: boolean; deletable: boolean | null; } interface ListFavoritesResult { favorites: EspnFavorite[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/addFavoriteCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.addFavorite({ id: "<id>", kind: "<kind>" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.addFavorite({"id": "<id>", "kind": "<kind>"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/addFavorite \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"id":"<id>","kind":"<kind>"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.addFavorite({ id: "<id>", kind: "<kind>" });createFantasyLeagueCreates a new free, private ESPN fantasy league (football, baseball, basketball or hockey) owned by the CALLER, with its name, size, scoring and…Arguments
Name Type Required sport"football" | "baseball" | "basketball" | "hockey"Yes namestringYes sizenumber4-20, default 10.No scoringTypestringE.g. "H2H_POINTS" (default), "H2H_CATEGORY", "ROTO".No draftTypestring"SNAKE" (default), "AUCTION", "OFFLINE".No draftDatestringISO instant.No seasonnumberNo Returns
CreateFantasyLeagueResultinterface CreateFantasyLeagueResult { leagueId: string | null; url: string | null; inviteUrl: string | null; raw: unknown; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/createFantasyLeagueCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.createFantasyLeague({ sport: "football", name: "<name>" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.createFantasyLeague({"sport": "football", "name": "<name>"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/createFantasyLeague \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"sport":"football","name":"<name>"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.createFantasyLeague({ sport: "football", name: "<name>" });proposeFantasyTradeProposes a trade from the CALLER's own ESPN fantasy team to another team in the same league, or accepts or declines one proposed to them.Arguments
Name Type Required argsProposeFantasyTradeArgsYes interface FantasyLeagueRef { sport: string; // "football" | "baseball" | "basketball" | "hockey" leagueId: string | number; teamId: number; // the caller's own team season?: number; scoringPeriodId?: number; } interface ProposeFantasyTradeArgs extends FantasyLeagueRef { toTeamId: number; sendPlayerIds: number[]; receivePlayerIds: number[]; }Returns
FantasyTransactionResultinterface FantasyTransactionResult { id: string | null; status: string | null; // the site's own labels, read the values off a result, never guess one from prose type: string; raw: unknown; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/proposeFantasyTradeCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.proposeFantasyTrade("<args>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.proposeFantasyTrade("<args>"))curl -X POST https://api.bowmark.ai/v1/sites/espn/proposeFantasyTrade \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":"<args>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.proposeFantasyTrade("<args>");removeFavoriteRemoves a team, league or player from the CALLER's My ESPN favourites.Arguments
Name Type Required idstringA favourite's id from listFavorites.Yes Returns
ListFavoritesResultinterface EspnFavorite { id: string; // ESPN's preference id kind: string | null; kindName: string | null; name: string | null; url: string | null; sortOrder: number | null; hidden: boolean; deletable: boolean | null; } interface ListFavoritesResult { favorites: EspnFavorite[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/removeFavoriteCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.removeFavorite({ id: "<id>" });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.removeFavorite({"id": "<id>"}))curl -X POST https://api.bowmark.ai/v1/sites/espn/removeFavorite \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"id":"<id>"}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.removeFavorite({ id: "<id>" });setFantasyLineupMoves players between the CALLER's starting lineup and bench in one of their own ESPN fantasy leagues for a scoring period.Arguments
Name Type Required argsSetFantasyLineupArgsYes interface FantasyLeagueRef { sport: string; // "football" | "baseball" | "basketball" | "hockey" leagueId: string | number; teamId: number; // the caller's own team season?: number; scoringPeriodId?: number; } interface SetFantasyLineupArgs extends FantasyLeagueRef { moves: { playerId: number; fromLineupSlotId: number; toLineupSlotId: number }[]; }Returns
FantasyTransactionResultinterface FantasyTransactionResult { id: string | null; status: string | null; // the site's own labels, read the values off a result, never guess one from prose type: string; raw: unknown; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/setFantasyLineupCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.setFantasyLineup("<args>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.setFantasyLineup("<args>"))curl -X POST https://api.bowmark.ai/v1/sites/espn/setFantasyLineup \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":"<args>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.setFantasyLineup("<args>");submitPicksEnters the CALLER's picks in one of ESPN's free prediction games (NFL Pick'em, Survivor, college Pick'em, Bowl Mania, Tournament Challenge) by…Arguments
Name Type Required challengestringE.g. "nfl-pickem-2026", gambit-api.fantasy.espn.com/apis/v1/challenges/ lists them.Yes picks{ propositionId: string; outcomeId: string }[]Yes entryNamestringNo Returns
SubmitPicksResultinterface SubmitPicksResult { entryId: string | null; picksSaved: number | null; raw: unknown; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/espn/submitPicksCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.espn.submitPicks({ challenge: "<challenge>", picks: {} });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.espn.submitPicks({"challenge": "<challenge>", "picks": {}}))curl -X POST https://api.bowmark.ai/v1/sites/espn/submitPicks \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"args":{"challenge":"<challenge>","picks":{}}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.espn.submitPicks({ challenge: "<challenge>", picks: {} });
Use it from code
- Node
npm i @bowmark/web - Python
pip install bowmark-web - HTTP
POST /v1/sites/espn/<function> - OpenAPI
/v1/sites/espn/openapi.json