Live Scores & Sports Data API

A live scores API returns the current and final score of a game, along with the status, teams, and stats around it, as the action happens, so an app or widget can show results without a human updating them. SportsGameOdds gives you that in one feed. Each /events object carries teams.home/teams.away, live scores.home/scores.away, status.started/status.ended/status.finalized, a per-market score for settling picks, and players.<playerID> for box-score detail across 28+ sports and 67+ leagues, and odds ship in the very same schema.

Why use SportsGameOdds for live scores

• Scores, status, and teams in one object. Every event returns teams.home and teams.away with their names, the live scores.home/scores.away tally, and an event-level status block (status.started, status.ended, status.finalized). One getEvents call renders a full scoreboard row.
• Box scores from players.<playerID> and stats. The players map resolves each playerID to its name and teamID, and player and team stats hang off the same event, so you build box scores and player cards without a second stats vendor.
• Schedules and results from the same feed. Filter startsAfter/startsBefore for upcoming fixtures, then re-query with finalized=true for settled results. Pre-match schedule, live scoreboard, and final box score all come from getEvents.
• Metadata endpoints fill in the rest. getSports, getLeagues, getTeams, getPlayers, and getStats give you sport, league, team, and player reference data (team names, colors, and identifiers) to power navigation, logos, and filters.
• Odds and results share one schema. The same call that shows the score also carries fairOdds, bookOdds, and per-book prices under byBookmaker, so an editorial page or widget can add a line or settle a pick without integrating a separate odds API.
• Normalized IDs across every sport. A consistent eventID, teamID, playerID, and oddID describe the same entity everywhere, so your scoreboard code stays identical whether you render NFL, NBA, or soccer.

How a live-scores app works with our data

Anyone can lay out a scoreboard. What's hard in a scores product is keeping clean, normalized results flowing across every sport in real time. Here's how the schema maps to each piece.

Render the live scoreboard

Query getEvents for a league (add live=true to scope to in-progress games) and read teams.home/teams.away for the matchup, scores.home/scores.away for the running score, and status for game state. status.started tells you a game is in progress, status.ended that play is over, and status.finalized that results are settled. That's enough to label a card Upcoming, Live, or Final without any second source.

Build box scores and player cards

For player-level detail, the event's players map resolves each playerID to a name, firstName/lastName, and teamID. Pair that with player and team stats on the event to assemble box scores, leaderboards, and player cards, then use getPlayers or getTeams to hydrate reference data like team names and colors for your layout.

Show schedules and final results

The same endpoint powers your schedule grid: filter startsAfter and startsBefore for upcoming events (games), then re-query the same eventIDs with finalized=true once they end to pull the final scores and each market's settled score. Pagination via cursor and nextCursor walks a full slate, so a season schedule and its results come from one feed.

Example request

Fetch recent finalized NFL games with their scores and results in one call:

curl "https://api.sportsgameodds.com/v2/events?leagueID=NFL&finalized=true" \
  -H "x-api-key: YOUR_API_KEY"

A trimmed event shows the matchup, game status, and a market's score, everything a scoreboard needs:

{
  "eventID": "4lronEc61vA9pcyqoRIa",
  "leagueID": "NFL",
  "teams": {
    "home": { "names": { "long": "Houston Texans" } },
    "away": { "names": { "long": "Buffalo Bills" } }
  },
  "status": {
    "started": true,
    "ended": true,
    "finalized": true,
    "displayLong": "Final"
  },
  "scores": { "home": 27, "away": 24 },
  "odds": {
    "points-home-game-ou-over": {
      "oddID": "points-home-game-ou-over",
      "started": true,
      "ended": true,
      "score": 27
    }
  },
  "players": {
    "JOSH_ALLEN_1_NFL": { "name": "Josh Allen", "teamID": "BUFFALO_BILLS_NFL" }
  }
}

Here status.ended and status.finalized mark the game as Final, scores gives the 27-24 line score, the home-points market's score of 27 settles that market, and players resolves each playerID for the box score. That's live scores and final results without a second API. See the docs and the fetching teams guide for the full reference data behind names, colors, and IDs.

SportsGameOdds vs building it yourself

You can stitch this together yourself, and it gives you full control. The real cost shows up later: you wire up a separate scores feed, a stats feed, and a metadata source per sport, then keep them aligned as each one quietly changes. SportsGameOdds pre-assembles that layer so you spend your time on the product.

Related use cases

• Sports Odds API for Betting Apps: odds, scores, and settlement in one feed.
• Odds API for Bet Tracking & Settlement: grade picks from the same score field.
• Live & In-Play Odds API: real-time odds alongside live scores.
• NFL odds & data: scores, stats, and markets for the NFL.
• Fetching teams guide: team names, colors, and IDs for your scoreboard.
• Pricing: per-event-object plans, including a free tier.