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.

Functions
35
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just ESPN

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/espn
Every site

One MCP server for ESPN and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both 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.

Read 28
  • draftPicksA league's draft pick by pick.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", "nhl".
    Yes
    seasonnumber
    Draft year; default ESPN's current draft.
    No
    roundnumber
    Only this round.
    No
    teamstring
    Only this team's picks, by abbreviation, name or nickname.
    No

    Returns DraftPicksResult

    interface 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/draftPicks

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    sportstring
    "football", "baseball", "basketball" or "hockey".
    Yes
    seasonnumber
    Season year, e.g. 2026.
    No
    limitnumber
    How many players to return, ranked by percent-rostered.
    No

    Returns FantasyPlayersResult

    interface 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/fantasyPlayers

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.fantasyPlayers({ sport: "football", limit: 5 });
  • getArticleThe full text of one ESPN story.

    Arguments

    NameTypeRequired
    articleIdstring
    Article id from news(), or an espn.com story URL carrying /story/_/id/<id>/.
    Yes

    Returns Article

    interface 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/getArticle

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    sportstring
    "football", "baseball", "basketball" or "hockey".
    Yes
    leagueIdstring | number
    The league id from a fantasy.espn.com URL, or the URL itself.
    Yes
    seasonnumber
    Season year, e.g. 2026.
    No

    Returns FantasyLeagueResult

    interface 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/getFantasyLeague

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.getFantasyLeague({ sport: "football", leagueId: "1249" });
  • getFantasyTeamOne team in an ESPN fantasy league.

    Arguments

    NameTypeRequired
    sportstring
    "football", "baseball", "basketball" or "hockey".
    Yes
    leagueIdstring | number
    The league id from a fantasy.espn.com URL, or the URL itself.
    Yes
    teamIdstring | number
    The team id inside that league (getFantasyLeague's teams[].id), or a URL carrying teamId=.
    Yes
    seasonnumber
    Season year, e.g. 2026.
    No

    Returns FantasyTeamResult

    interface 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/getFantasyTeam

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    eventIdstring
    Event id from scoreboard or teamSchedule.
    Yes
    leaguestring
    League slug (required to construct the API URL).
    Yes

    Returns GameDetail

    interface 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/getGame

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.getGame({ eventId: "401872981", league: "nfl" });
  • getPlayerOne player's page, team, position, jersey, age, height, weight, college, status and headshot.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    athleteIdstring
    ESPN athlete id, from search's or teamRoster's results.
    Yes

    Returns Player

    interface 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/getPlayer

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes
    teamstring
    Team abbreviation, name, or nickname (e.g. "ARI", "Cardinals", "Arizona Cardinals").
    Yes

    Returns GetTeamResult

    interface 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/getTeam

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    league"nfl" | "nba" | "wnba" | "mlb" | "nhl"
    Default "nfl".
    No
    teamstring
    One team, by name or abbreviation: "Chiefs", "Kansas City Chiefs", "KC".
    No

    Returns EspnInjuryReport

    interface 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/injuries

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.injuries();
  • listFavoritesThe CALLER's My ESPN favourites.

    Arguments

    None.

    Returns ListFavoritesResult

    interface 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/listFavorites

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    sportstring
    Narrow to one sport's leagues, by the slug listLeagues() (no args) returns.
    No

    Returns EspnLeagueCatalog

    interface 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/listLeagues

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.listLeagues();
  • listMyFantasyTeamsThe CALLER's own ESPN fantasy teams across every game (football, baseball, basketball, hockey).

    Arguments

    None.

    Returns ListMyFantasyTeamsResult

    interface 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/listMyFantasyTeams

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.listMyFantasyTeams();
  • listTeamsEvery team in a league with its ESPN id, abbreviation, name, location, colours and logo.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes

    Returns ListTeamsResult

    interface 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/listTeams

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.listTeams({ league: "nfl" });
  • listVideosESPN's latest highlight and analysis video clips for a league, optionally one team's.

    Arguments

    NameTypeRequired
    leaguestring
    A league slug or name, e.g. "nfl", "nba", "college-football".
    Yes
    teamstring
    Keep only clips tagged with a team whose name contains this.
    No
    limitnumber
    Default 25, max 50.
    No

    Returns ListVideosResult

    interface 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/listVideos

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.listVideos({ league: "nfl" });
  • newsThe latest ESPN headlines for a league, optionally narrowed to one team.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    teamstring
    Narrow to articles tagged with this team, by name or abbreviation.
    No

    Returns NewsResult

    interface 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/news

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.news({ league: "nfl" });
  • oddsThe betting lines ESPN shows for a league's games.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", "nhl", etc.
    Yes
    gameIdstring
    One game's ESPN id (from scoreboard).
    No

    Returns OddsResult

    interface 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/odds

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.odds({ league: "nfl" });
  • playerGameLogOne player's game-by-game log for a season.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    athleteIdstring
    ESPN athlete id, from search's or teamRoster's results.
    Yes

    Returns PlayerGameLogResult

    interface 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/playerGameLog

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.playerGameLog({ league: "nfl", athleteId: "3139477" });
  • playerStatsOne player's full statistics.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    athleteIdstring
    ESPN athlete id, from search's or teamRoster's results.
    Yes

    Returns PlayerStatsResult

    interface 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/playerStats

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    leaguestring
    "college-football" (default) or "mens-college-basketball".
    No
    pollstring
    Narrow to one poll by name or short name, e.g. "AP".
    No

    Returns RankingsResult

    interface 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/rankings

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.rankings({ league: "college-football" });
  • scoreboardA league's games for today, a date, a date range or a football week.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "eng.1", etc.
    Yes
    datestring
    Optional: one specific date (YYYY-MM-DD format).
    No
    datesstring
    Optional: 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
    weeknumber
    Optional: for football leagues only.
    No

    Returns ScoreboardResult

    interface 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/scoreboard

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.scoreboard({ league: "nfl" });
  • standingsA league's current standings by conference and division.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes
    seasonnumber
    Optional: season year (e.g. 2025).
    No

    Returns StandingsResult

    interface 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/standings

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.standings({ league: "nfl" });
  • statLeadersA league's season leaderboard.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes
    categorystring
    Narrow to one category by key or display name, case-insensitive.
    No

    Returns StatLeadersResult

    interface 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/statLeaders

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes
    teamstring
    Team abbreviation, name, or nickname.
    Yes

    Returns TeamDepthChartResult

    interface 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/teamDepthChart

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    teamstring
    Team abbreviation, name, or nickname (e.g. "ARI", "Cardinals", "Arizona Cardinals").
    Yes

    Returns TeamRosterResult

    interface 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/teamRoster

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.teamRoster({ league: "nfl", team: "ARI" });
  • teamScheduleOne team's full season schedule.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc. Common names resolved by resolveLeague.
    Yes
    teamstring
    Team abbreviation, name, or nickname (e.g., "ARI", "Cardinals", "Arizona Cardinals").
    Yes
    seasonnumber
    Season year (e.g., 2026).
    Yes
    seasonTypestring
    Season type: "preseason", "regular", or "postseason" (optional, defaults to "regular").
    No

    Returns TeamScheduleResult

    interface 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/teamSchedule

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", etc.
    Yes
    teamstring
    Team abbreviation, name, or nickname.
    Yes

    Returns TeamStatsResult

    interface 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/teamStats

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.teamStats({ league: "nfl", team: "ARI" });
  • transactionsA league's recent transactions.

    Arguments

    NameTypeRequired
    leaguestring
    League slug: "nfl", "nba", "mlb", "nhl", etc.
    Yes
    teamstring
    Narrow to one team by abbreviation, name or nickname.
    No
    pagenumber
    1-based page, default 1.
    No
    limitnumber
    Rows per page, default 25, max 100.
    No

    Returns TransactionsResult

    interface 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/transactions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.transactions({ league: "nfl" });
Act 7
  • 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

    NameTypeRequired
    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 FantasyTransactionResult

    interface 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/addDropFantasyPlayer

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.addDropFantasyPlayer("<args>");
  • addFavoriteAdds a team, league or player to the CALLER's My ESPN favourites.

    Arguments

    NameTypeRequired
    idstring
    ESPN preference id, as listFavorites returns it.
    Yes
    kindstring
    Type.code, "team", "league", "player", "fantasy".
    Yes

    Returns ListFavoritesResult

    interface 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/addFavorite

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    sport"football" | "baseball" | "basketball" | "hockey"Yes
    namestringYes
    sizenumber
    4-20, default 10.
    No
    scoringTypestring
    E.g. "H2H_POINTS" (default), "H2H_CATEGORY", "ROTO".
    No
    draftTypestring
    "SNAKE" (default), "AUCTION", "OFFLINE".
    No
    draftDatestring
    ISO instant.
    No
    seasonnumberNo

    Returns CreateFantasyLeagueResult

    interface CreateFantasyLeagueResult {
      leagueId: string | null;
      url: string | null;
      inviteUrl: string | null;
      raw: unknown;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/espn/createFantasyLeague

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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 FantasyTransactionResult

    interface 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/proposeFantasyTrade

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.proposeFantasyTrade("<args>");
  • removeFavoriteRemoves a team, league or player from the CALLER's My ESPN favourites.

    Arguments

    NameTypeRequired
    idstring
    A favourite's id from listFavorites.
    Yes

    Returns ListFavoritesResult

    interface 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/removeFavorite

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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 FantasyTransactionResult

    interface 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/setFantasyLineup

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    challengestring
    E.g. "nfl-pickem-2026", gambit-api.fantasy.espn.com/apis/v1/challenges/ lists them.
    Yes
    picks{ propositionId: string; outcomeId: string }[]Yes
    entryNamestringNo

    Returns SubmitPicksResult

    interface SubmitPicksResult {
      entryId: string | null;
      picksSaved: number | null;
      raw: unknown;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/espn/submitPicks

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.espn.submitPicks({ challenge: "<challenge>", picks: {} });

Use it from code