DEV Community: SportsAPIs.dev

Live Sports Odds APIs: WebSocket vs REST, Latency and In-Play Feeds

SportsAPIs.dev — Thu, 15 Oct 2026 21:28:24 +0000

This post first appeared on SportsAPIs.dev.

What is a Live Sports Odds API?

A live sports odds API (also called in-play or in-game betting API) provides real-time betting odds that update continuously while games are in progress. Unlike pregame odds that remain relatively stable until game time, live odds change dynamically based on score, time remaining, momentum shifts, injuries, and other in-game events.

Live betting is the fastest-growing segment of sports wagering, accounting for over 50% of handle at many sportsbooks. Bettors love the excitement of reacting to game flow, and odds APIs enable developers to build applications that capitalize on this trend.

Why Live Odds APIs Are Different

Live sports odds APIs require fundamentally different infrastructure than pregame odds:

Real-time updates: Odds change every few seconds, requiring WebSocket connections or aggressive polling
Low latency: Milliseconds matter for arbitrage and value betting opportunities
Higher costs: Real-time data feeds from sportsbooks are expensive to license and maintain
Complex markets: In-play markets include next-to-score, next-quarter winner, and dynamic player props
Reliability requirements: Downtime during games = lost revenue for betting apps

If you're building a live betting application, arbitrage tool, or real-time odds comparison site, a dedicated live sports odds API is essential.

WebSocket vs REST: What's the Difference?

Understanding the technology behind live odds delivery is crucial for choosing the right API:

REST API (Polling)

Traditional HTTP requests where your application repeatedly asks "what are the current odds?" at regular intervals.

Advantages:

Simpler to implement (standard HTTP requests)
Works with any programming language
Easier debugging and testing
Stateless (no persistent connections)

Limitations:

Higher latency (5-60 second delays typical)
Wastes API calls polling for unchanged data
Inefficient bandwidth usage
Not suitable for time-sensitive arbitrage

Example polling code:

// Poll for odds every 10 seconds
setInterval(async () => {
  const odds = await fetch('https://api.example.com/live-odds');
  updateDisplay(await odds.json());
}, 10000); // 10-second delay between updates

WebSocket API (Streaming)

Persistent two-way connection where the server pushes odds updates to you instantly when they change.

Advantages:

Sub-second latency (often <500ms)
Only receive updates when odds actually change
Efficient bandwidth (push model)
Perfect for arbitrage and live betting
Lower API costs (pay for connection, not per-request)

Limitations:

More complex implementation
Requires WebSocket library support
Connection management (reconnects, heartbeats)
Typically higher monthly cost than REST

Example WebSocket code:

// WebSocket connection for real-time odds
const ws = new WebSocket('wss://api.example.com/live-odds');

ws.onmessage = (event) => {
  const oddsUpdate = JSON.parse(event.data);
  updateDisplay(oddsUpdate); // Instant updates when odds change
};

ws.onclose = () => reconnect(); // Handle disconnections

Which Should You Choose?

Use WebSocket for: Live betting apps, arbitrage tools, real-time odds comparison, time-sensitive applications
Use REST polling for: Budget projects, infrequent updates (hourly), pregame-focused apps, MVPs/prototypes

Many providers offer both options. Start with REST to build your app, then upgrade to WebSocket when you need real-time performance.

Understanding Latency in Live Odds APIs

Latency (the delay between a real-world event and seeing updated odds) is critical for live betting applications. Here's what affects latency:

Sources of Latency

Sportsbook data delay: Time for sportsbooks to update their own systems (1-5 seconds)
API provider processing: Time to normalize and distribute data (0.1-2 seconds)
Network transmission: Data traveling over the internet (0.05-0.5 seconds)
Your application processing: Parsing and displaying data (0.01-0.2 seconds)

Total latency: Typically ranges from 2-10 seconds for live odds, though premium WebSocket APIs can achieve sub-second from sportsbook to your app.

Why Latency Matters

Arbitrage: Opportunities often last only 5-30 seconds. High latency = missed opportunities
User experience: Outdated odds frustrate users and reduce trust
Market efficiency: Sharp bettors need current odds to identify value
Risk management: Delayed odds can lead to accepting changed lines

How Much Latency Can Your App Tolerate?

Not every live app needs a WebSocket. Match the feed to the job:

Use case	Latency you can live with	Feed that fits
Live betting / in-play wagering	Under 500ms, ideally under 200ms	WebSocket on a premium plan
Odds comparison and arbitrage	1-5 seconds	WebSocket, or REST polled every 5-10 seconds
Live score tracking	5-30 seconds	REST polled every 10-30 seconds
Fantasy and DFS scoring	30-60 seconds	REST polled every 30-60 seconds
Score widgets on news sites	1-5 minutes	REST with caching

Latency Benchmarks by Feed Type

Premium WebSocket APIs: 0.5-2 seconds
REST with fast polling: 5-15 seconds (at 10s intervals)
Standard REST polling: 30-60 seconds (budget implementations)

Test latency during free trials to ensure it meets your needs. Request sample WebSocket feeds or monitor timestamps in API responses.

What Can You Build with Live Odds APIs?

Live Betting Applications

Build iOS/Android apps or web platforms that display in-play betting markets with real-time odds updates. Show live scores alongside current betting lines for maximum engagement.

Required: WebSocket API, low latency (<3s), reliable uptime

Arbitrage Bots

Automated systems that detect price discrepancies across sportsbooks and alert users to risk-free profit opportunities. Live arbitrage is highly time-sensitive.

Required: Sub-second updates, wide sportsbook coverage, WebSocket

Live Odds Comparison Sites

Real-time odds comparison platforms showing which sportsbook offers the best live lines for in-progress games. Refresh automatically as odds change.

Required: WebSocket or fast polling, multiple sportsbooks

Positive EV Alerts

Systems that compare your predictive models to live market odds to identify bets with positive expected value in real-time.

Required: Fast updates, historical odds for model training

Live Line Movement Trackers

Visualize how odds change throughout a game. Track line movements to understand sharp money, public betting, and market reactions.

Required: Historical live odds, frequent updates

Discord/Telegram Live Alerts

Bots that push notifications to communities when favorable live betting opportunities arise based on custom criteria.

Required: WebSocket for speed, custom filtering logic

Live Betting Analytics

Tools that analyze in-play betting patterns, calculate live win probabilities, and compare to market odds to find inefficiencies.

Required: Live odds + live stats/scores, fast updates

Hedge Calculators

Real-time hedge calculators that show optimal live bets to lock in profit or minimize loss on existing pregame wagers.

Required: Live odds, user bet tracking

Live Scores vs Live Odds APIs

People search for "real-time sports API" and mean one of two different products. A live scores feed tells you what happened in the game. A live odds feed tells you what the sportsbooks think will happen next. They run at different speeds and cost different amounts.

	Live scores API	Live odds API
Data	Score, period, game clock, play-by-play, live player stats	In-play moneylines, spreads, totals, live props, line movement across books
Typical latency	1-30 seconds	Under 2 seconds on good feeds
Built for	Score apps, news widgets, fantasy scoring, push alerts	Live betting, in-play comparison, live arbitrage, CLV tracking

If your app shows both (a touchdown lands and the new line appears next to it), you need them in sync. Some providers bundle scores and odds in one feed; others make you join two. The SportsAPIs.dev directory marks which providers cover each, and the free ESPN endpoints are a fair start for scores alone.

How to Integrate a Live Sports Odds API

Integrating live odds requires different considerations than pregame data:

Step 1: Choose WebSocket vs REST

For true real-time applications, prioritize APIs offering WebSocket support. For less time-sensitive use cases, REST with aggressive polling (every 5-10 seconds) may suffice.

Step 2: Implement Connection Management

WebSocket connections require robust error handling:

// WebSocket connection with auto-reconnect
let ws;
let reconnectInterval = 5000;

function connect() {
  ws = new WebSocket('wss://api.example.com/live');

  ws.onopen = () => {
    console.log('Connected to live odds feed');
    // Subscribe to specific games/markets
    ws.send(JSON.stringify({
      action: 'subscribe',
      sports: ['basketball_nba', 'americanfootball_nfl']
    }));
  };

  ws.onmessage = (event) => {
    const update = JSON.parse(event.data);
    processOddsUpdate(update);
  };

  ws.onerror = (error) => console.error('WebSocket error:', error);

  ws.onclose = () => {
    console.log('Disconnected, reconnecting...');
    setTimeout(connect, reconnectInterval);
  };
}

connect();

Step 3: Optimize Display Updates

Don't update your UI on every single odds change. Batch updates to prevent flickering:

let pendingUpdates = {};

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  pendingUpdates[update.game_id] = update;
};

// Batch update UI every 500ms
setInterval(() => {
  Object.values(pendingUpdates).forEach(update => {
    updateGameOdds(update);
  });
  pendingUpdates = {};
}, 500);

Step 4: Handle Rate Limits

Even WebSocket APIs may limit:

Number of concurrent connections
Number of subscribed games/markets
Messages per second

Subscribe only to games/markets you're actively displaying to users.

Step 5: Monitor Latency

Track timestamps in API responses to measure end-to-end latency:

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  const apiTime = new Date(update.timestamp);
  const receiveTime = new Date();
  const latency = receiveTime - apiTime;

  console.log(`Latency: ${latency}ms`);
  monitorLatency(latency); // Alert if latency spikes
};

Step 6: Implement Fallbacks

Have a backup plan if WebSocket connections fail:

Fall back to REST polling if WebSocket disconnects repeatedly
Cache last-known odds to display during brief outages
Show users a "Live odds temporarily unavailable" message

Live Odds API Pricing

Live sports odds APIs cost more than pregame-only APIs due to infrastructure requirements:

Typical Pricing Tiers

Free trials: 7-14 days from various providers to test latency and features
Entry-level: $100-300/month for REST polling access with limited sportsbooks
Professional: $300-800/month for WebSocket access, multiple sports, comprehensive coverage
Enterprise: $1000+/month for dedicated connections, SLA guarantees, premium support

Cost Factors

Update frequency: WebSocket costs more than REST polling
Sportsbook count: More books = higher licensing costs
Sports coverage: Niche sports may cost extra
Request volume: Some charge per message/update
Features: Player props and SGP odds increase cost

Start with free trials to validate your concept before committing to expensive plans.

Frequently Asked Questions

What is a live sports odds API?

A live sports odds API provides real-time betting odds that update continuously during games. Unlike pregame odds that are static until game time, live odds (also called in-play or in-game odds) change based on score, time remaining, and in-game events. These APIs use WebSocket connections or rapid polling to deliver sub-second to 10-second updates to betting applications.

Which API has the fastest live odds updates?

Several providers are known for sub-second live odds via WebSocket connections. Update speed depends on both the sportsbook's data feed and the API provider's infrastructure. WebSocket APIs consistently outperform REST polling, delivering updates in under 2 seconds vs 5-60 seconds for polling.

How much do live odds APIs cost?

Live sports odds APIs typically cost $200-1000+/month depending on update frequency, sportsbook coverage, and request volumes. This is significantly higher than pregame-only APIs ($20-100/month) due to infrastructure requirements for real-time data. Entry-level live odds start around $100-300/month, while professional WebSocket access costs $300-800/month. Most providers offer free trials to test latency and reliability.

What's the difference between WebSocket and REST for live odds?

REST APIs require you to repeatedly poll for updates (every 5-60 seconds), causing delays and wasting requests when odds haven't changed. WebSocket APIs maintain a persistent connection where the server pushes updates to you instantly when odds change, achieving sub-second latency. WebSockets are essential for live betting apps, arbitrage detection, and real-time odds comparison, though they cost more than REST-only access.

What sports offer live odds through APIs?

Most major sports offer live in-play betting: NFL, NBA, MLB, NHL, NCAAF, NCAAB, Soccer (Premier League, Champions League, MLS), Tennis, MMA/UFC, Cricket, Rugby, and Esports. Live odds availability and market depth vary by sport: high-scoring sports like basketball have more frequent updates than baseball or soccer.

Can I get live player props through an API?

Yes, some APIs provide live player props during games (points, rebounds, strikeouts, etc.). However, live player props are typically premium features requiring higher-tier paid plans. Not all sportsbooks offer live player props, so coverage varies by provider. This guide to player props APIs covers the details.

How do I test live odds API latency?

Use free trials to test real-world latency. Connect during live games and compare the API's odds timestamps to your system clock. Measure the delay between a game event (score change) and updated odds appearing in your app. Expect 1-10 second total latency depending on the API. WebSocket connections should show sub-3-second latency, while REST polling typically shows 10-60 seconds.

Are free live odds APIs available?

Very few APIs offer truly free live odds due to high infrastructure costs. Some providers offer limited free tiers (e.g., 500 requests/month) which technically allows live odds via polling, but this is insufficient for real-time applications (you'd exhaust it in hours). Your best option is free trials (typically 7-14 days) to build and test your live betting app before committing to paid plans.

What latency is acceptable for arbitrage betting?

For live arbitrage, you need sub-3-second latency. Arbitrage opportunities in live betting typically last only 5-30 seconds before odds adjust. If your API has 10+ second latency, most opportunities will disappear before you can capitalize. WebSocket APIs are recommended for arbitrage detection with their sub-second update speeds.

Compare live odds providers by WebSocket support, latency and sportsbook coverage in the SportsAPIs.dev directory.

ESPN API: Free Sports Data for Scores, Stats and News

SportsAPIs.dev — Thu, 15 Oct 2026 21:18:47 +0000

This post first appeared on SportsAPIs.dev.

What is the ESPN API?

The ESPN API refers to a collection of undocumented endpoints that developers have discovered by reverse-engineering ESPN's web and mobile applications. While ESPN doesn't offer an official public API, these hidden endpoints provide free access to a wealth of sports data:

Real-time Scores: Live scoreboards across all major sports
Team & Player Stats: Comprehensive statistics and performance data
News & Headlines: Latest sports news articles
Standings & Rankings: League standings and power rankings
Game Summaries: Play-by-play data, box scores, and game details
Schedules: Upcoming games and event calendars

Key Benefits

Free Access: No subscription or payment required
No Authentication: No API key or token needed
JSON Responses: Clean, structured data format
Comprehensive Coverage: All major US sports plus international soccer

API Base URLs

ESPN's hidden API uses several base domains, each serving different types of data:

Domain	Purpose
`site.api.espn.com`	General site data - scores, news, teams, standings
`sports.core.api.espn.com`	Core sports data - athletes, detailed stats, odds, venues
`site.web.api.espn.com`	Web-specific APIs - search, game summaries, athlete overviews
`fantasy.espn.com`	Fantasy sports data (may require authentication for private leagues)
`cdn.espn.com`	Content delivery - optimized for speed and caching

Supported Sports & Leagues

The ESPN API covers a wide range of sports and leagues. Here are the most commonly used:

Football

NFL (football/nfl)
College Football (football/college-football)

Basketball

NBA (basketball/nba)
WNBA (basketball/wnba)
Men's CBB (basketball/mens-college-basketball)
Women's CBB (basketball/womens-college-basketball)

Baseball

MLB (baseball/mlb)
College Baseball (baseball/college-baseball)

Hockey

NHL (hockey/nhl)

Soccer

MLS (soccer/usa.1)
Premier League (soccer/eng.1)
La Liga (soccer/esp.1)
And many more...

Other Sports

Golf
Tennis
MMA/UFC
Racing

Key Endpoints

Most endpoints follow a consistent pattern: /apis/site/v2/sports/{sport}/{league}/{endpoint}

Endpoint	Description	Example
`/scoreboard`	Live scores and game status	`/sports/football/nfl/scoreboard`
`/news`	Latest news articles	`/sports/basketball/nba/news`
`/teams`	All teams in a league	`/sports/baseball/mlb/teams`
`/teams/{id}`	Specific team details	`/sports/football/nfl/teams/12`
`/summary`	Game details with box score	`/sports/basketball/nba/summary?event=401234567`
`/standings`	League standings	`/sports/hockey/nhl/standings`
`/rankings`	Power rankings (college)	`/sports/football/college-football/rankings`

Common Query Parameters

Parameter	Description	Example
`dates`	One day (YYYYMMDD) or a whole month (YYYYMM). Ranges return HTTP 400, see date filters	`?dates=20251201`
`limit`	Maximum number of results	`?limit=50`
`season`	Specific season year	`?season=2025`
`seasontype`	Season type (1=preseason, 2=regular, 3=postseason)	`?seasontype=2`
`week`	Specific week (football)	`?week=10`
`groups`	Conference/division filter	`?groups=80` (FBS)

ESPN Game Summary Endpoint (summary?event=)

The summary endpoint returns everything ESPN has on one game: box score, play-by-play, win probability, betting lines, injuries and news. It is the ESPN endpoint developers search for most, and it has the least documentation.

https://site.api.espn.com/apis/site/v2/sports/{sport}/{league}/summary?event={eventId}
https://site.web.api.espn.com/apis/site/v2/sports/{sport}/{league}/summary?event={eventId}

Both hosts returned the same JSON for the same game in our tests. Pick either one.

Where the event ID comes from

Every scoreboard response has an events array, and each event has an id. That id is your event value. For example, basketball/nba/scoreboard?dates=20250605 returns Game 1 of the 2025 NBA Finals (Pacers at Thunder) with id 401766122, so the summary URL is basketball/nba/summary?event=401766122. A missing or wrong ID returns HTTP 400.

What the summary response contains

Key	What it holds
`header`	Teams, score, date, status and which side is home
`boxscore`	Team stats (`teams`) and player stat lines (`players`)
`plays`	Play-by-play. Our NBA Finals test game had 503 plays, each with an `id`, `text`, `period` and `clock`
`winprobability`	Home win probability after every play (see below)
`leaders`	Top performer per stat category for each team
`odds`, `pickcenter`, `againstTheSpread`	Betting lines and against-the-spread records. Often empty for finished games: both were empty for our NBA test game
`injuries`	Injury report for both teams
`gameInfo`	Venue, attendance and officials
`standings`, `seasonseries`	League table and the season head-to-head
`news`, `article`, `videos`	Recap and highlight content

Other sports use the same path with their own sport and league. Football responses add drives and scoringPlays. Soccer responses add keyEvents (a match timeline), commentary and rosters. A 2026 World Cup match looks like soccer/fifa.world/summary?event=760506 (Portugal vs Spain).

ESPN Win Probability Data

ESPN publishes a win probability for every play, and there are two ways to get it. Use the summary endpoint unless you have a reason not to.

From the summary endpoint

The winprobability array has one row per play:

{"homeWinPercentage": 0.665, "tiePercentage": 0.0, "playId": "4017661224"}

Values are fractions, not percents. The away side's chance is 1 - homeWinPercentage - tiePercentage. To see which play moved the number, match playId to the id of an entry in plays:

import requests

event_id = '401766122'  # 2025 NBA Finals, Game 1
url = f'https://site.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event={event_id}'
data = requests.get(url).json()

plays = {p['id']: p for p in data['plays']}
for row in data['winprobability'][-5:]:
    play = plays.get(row['playId'], {})
    clock = play.get('clock', {}).get('displayValue', '')
    print(f"{row['homeWinPercentage']:.1%}  Q{play.get('period', {}).get('number')} {clock}  {play.get('text', '')}")

From the core API

https://sports.core.api.espn.com/v2/sports/basketball/leagues/nba/events/{eventId}/competitions/{eventId}/probabilities

For NBA games the competition ID is the same as the event ID. This version is paginated (?limit= and ?page=) and each item is a $ref link, so every play costs one more request. The records do carry extra fields: awayWinPercentage, spreadCoverProbHome and totalOverProb. The spread and total fields were all 0 in our test, so the summary array gives you the same useful numbers in one call.

ESPN Scoreboard URLs by League

Every URL below returned HTTP 200 when we tested it. With no dates parameter you get today's games, or the current week for football.

League	Scoreboard URL
NBA	`https://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard`
NFL	`https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard`
College football	`https://site.api.espn.com/apis/site/v2/sports/football/college-football/scoreboard`
MLB	`https://site.api.espn.com/apis/site/v2/sports/baseball/mlb/scoreboard`
NHL	`https://site.api.espn.com/apis/site/v2/sports/hockey/nhl/scoreboard`
Premier League	`https://site.api.espn.com/apis/site/v2/sports/soccer/eng.1/scoreboard`
La Liga	`https://site.api.espn.com/apis/site/v2/sports/soccer/esp.1/scoreboard`
FIFA World Cup	`https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard`
Every soccer league	`https://site.api.espn.com/apis/site/v2/sports/soccer/all/scoreboard`
PGA Tour	`https://site.api.espn.com/apis/site/v2/sports/golf/pga/scoreboard`

Cricket is the odd one out. It takes a numeric league ID in place of a slug: cricket/8048/scoreboard returned a match, while cricket/scoreboard returned 404.

Date filters

Format	Example	What we got back
YYYYMMDD	`basketball/nba/scoreboard?dates=20250605`	One day: Game 1 of the 2025 NBA Finals
YYYYMM	`basketball/nba/scoreboard?dates=202506`	A whole month: all 7 games of the 2025 NBA Finals
YYYYMM	`soccer/fifa.world/scoreboard?dates=202606`	79 World Cup matches from June 2026
Season + week	`football/nfl/scoreboard?dates=2025&seasontype=2&week=1`	Week 1 of the 2025 NFL regular season (16 games)
YYYYMMDD-YYYYMMDD	`basketball/nba/scoreboard?dates=20250601-20250630`	HTTP 400. Ranges failed for every league we tried

Need a range? Request it month by month and filter the dates yourself.

Code Examples

Here are practical examples for fetching data from the ESPN API:

Get NFL Scores

// Fetch today's NFL scores
fetch('https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard')
  .then(response => response.json())
  .then(data => {
    data.events.forEach(game => {
      console.log(game.name, game.status.type.description);
    });
  });

import requests

# Fetch today's NFL scores
url = 'https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard'
response = requests.get(url)
data = response.json()

for game in data['events']:
    print(game['name'], game['status']['type']['description'])

# Fetch today's NFL scores
curl 'https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard'

Get NBA Game Summary

// Fetch detailed game data (replace eventId with actual game ID)
const eventId = '401584793';
const url = `https://site.web.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event=${eventId}`;

fetch(url)
  .then(response => response.json())
  .then(data => {
    console.log('Boxscore:', data.boxscore);
    console.log('Play-by-play:', data.plays);
  });

import requests

# Fetch detailed game data
event_id = '401584793'
url = f'https://site.web.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event={event_id}'

response = requests.get(url)
data = response.json()

print('Boxscore:', data.get('boxscore'))
print('Play-by-play:', data.get('plays'))

Get Scores for Specific Date

// Fetch MLB scores for a specific date
const date = '20251001'; // YYYYMMDD format
fetch(`https://site.api.espn.com/apis/site/v2/sports/baseball/mlb/scoreboard?dates=${date}`)
  .then(response => response.json())
  .then(data => console.log(data));

ESPN API 403 and 400 Errors

403 Forbidden

ESPN serves these endpoints through a CDN that blocks some scripted traffic. In our tests, a script that sent a copied Chrome User-Agent header got 403 on every request. The same URLs returned 200 with the default headers of curl, Python requests and Node fetch. If your script sets a browser User-Agent, delete that header first.

If the 403 continues after that, slow down and cache what you fetch. ESPN publishes no rate limit, so there is no safe number to aim for.

400 Bad Request

No valid event ID: summary needs ?event= with an id from a scoreboard response
A date range: ?dates=20250601-20250630 fails. Use one day or one month

200 with an empty events array

That means no games on that date, not a broken endpoint. Try a date you know had games.

Limitations & Considerations

Important: Unofficial API

The ESPN API is not officially supported. Keep these limitations in mind:

No Official Documentation: These endpoints are undocumented and discovered through reverse engineering
No Stability Guarantee: ESPN can modify or remove endpoints at any time without notice
Unknown Rate Limits: There's no published information about rate limiting or usage quotas
No Support: ESPN does not provide developer support for these endpoints
Terms of Service: Heavy automated usage may violate ESPN's terms of service

Recommendations

For Hobby Projects: The ESPN API works great for personal projects, learning, and experimentation
For Production Apps: Consider official sports data providers for applications requiring guaranteed uptime and support
Error Handling: Implement robust error handling since endpoints may change unexpectedly
Caching: Cache responses to reduce API calls and improve reliability

Community Resources

These community-maintained resources provide additional documentation and tools for working with the ESPN API:

ESPN API GitHub Repository: Comprehensive community documentation with endpoint references and examples
ESPN Hidden API Gist: Original endpoint discovery documentation with URL patterns for multiple sports
ESPN API Tutorial: Step-by-step guide on accessing ESPN's free sports data endpoints
ESPN Hidden API Guide: Getting started guide with best practices and common use cases
GPWA Forum Discussion: Community forum thread with additional endpoint discoveries and tips

Frequently Asked Questions

Does ESPN have a free API?

ESPN does not offer an official public API, but developers have discovered undocumented endpoints that provide free access to scores, stats, news, and standings data. These hidden APIs require no authentication or API key, making them accessible for personal projects and experimentation.

Is the ESPN API official?

No. The ESPN API endpoints discussed here are unofficial and undocumented. They were discovered by reverse-engineering ESPN's web and mobile applications. ESPN does not provide official API documentation, support, or any service level agreements for these endpoints.

What sports does the ESPN API cover?

The ESPN API covers NFL, NBA, MLB, NHL, WNBA, college football, men's and women's college basketball, college baseball, MLS, international soccer leagues (Premier League, La Liga, Bundesliga, Serie A, etc.), golf, tennis, MMA/UFC, racing, and many other sports.

Do I need an API key for the ESPN API?

No. The ESPN hidden API endpoints are publicly accessible and do not require authentication, API keys, or tokens. You can make simple HTTP GET requests to retrieve data. However, private fantasy league data may require authentication cookies.

Is the ESPN API reliable for production use?

The ESPN API is not recommended for production applications that require guaranteed stability and uptime. Since these are unofficial endpoints, ESPN can modify or remove them at any time without notice. For production applications, consider using official sports data providers that offer documentation, support, and SLAs.

How do I get NBA scores from the ESPN API?

To get NBA scores, make a GET request to: https://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard. The response includes all games for the current day with scores, team info, and game status. Add ?dates=YYYYMMDD to get scores for a specific date.

What is the difference between site.api.espn.com and site.web.api.espn.com?

For the game summary endpoint, nothing that matters. Both hosts returned the same JSON for the same event in our tests. site.web.api.espn.com also serves some web-only data, such as search and athlete overviews.

How do I get win probability from the ESPN API?

Call the summary endpoint for a game, for example https://site.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event=401766122, and read the winprobability array. Each row has homeWinPercentage, tiePercentage and a playId that matches a play in the plays array. The full example is in the win probability section above.

Why does the ESPN API return 403 Forbidden?

In our tests, ESPN returned 403 when a script sent a copied browser User-Agent header. Remove that header and let your HTTP client send its default. The same requests then returned 200. The 403 and 400 errors section above has more.

Does the ESPN API have a rate limit?

ESPN does not publish one. We did not hit a limit during our tests, but heavy traffic can get blocked without warning. Cache responses and do not poll faster than your app needs.

If you outgrow the hidden endpoints, compare the official providers side by side in the SportsAPIs.dev directory.

Historical Odds APIs: Pinnacle and Bet365 Closing Lines for Backtesting

SportsAPIs.dev — Thu, 15 Oct 2026 21:18:30 +0000

This post first appeared on SportsAPIs.dev.

Why Historical Odds Data Matters

Historical odds data is essential for serious sports bettors and analytics professionals. Unlike current odds which show today's lines, historical odds APIs provide access to past betting lines, enabling critical analysis:

Backtesting Betting Models: Test your betting strategies against years of real odds data to validate performance
Closing Line Value (CLV): Compare your bet prices to closing lines to measure betting skill
Line Movement Analysis: Study how odds change from opening to closing to identify sharp money
Sportsbook Comparison: Analyze which bookmakers historically offer the best prices
Market Efficiency Studies: Research betting market behavior and predictive accuracy

The gold standard for historical odds is sharp sportsbook closing lines, lines from books that accept professional bettors and maintain high limits, making their odds highly efficient and widely used as industry benchmarks.

Finding Historical Odds Providers

When evaluating historical odds providers, consider these key factors:

Historical Depth: How far back does the data go? (90 days to 10+ years)
Sharp Closing Lines: Does it include closing lines from sharp sportsbooks?
Sportsbook Coverage: Which bookmakers are included?
Data Format: API access vs. bulk CSV downloads
Update Frequency: How often is historical data updated?

Sharp Closing Lines & Why They Matter

Sharp sportsbooks, those that accept professional bettors and maintain high limits, produce the most efficient closing lines in the market. These lines are critical for historical analysis because:

Market Efficiency: Sharp books accept professional action, making their lines reflect true market consensus
High Limits: Large bet limits mean odds aren't easily moved by small wagers
Closing Line Value (CLV): Beating the closing line at a sharp book is the industry benchmark for measuring betting skill
No Account Limits: Sharp books don't ban winners, ensuring honest and efficient prices

Comparing sharp book closing lines against recreational sportsbook lines reveals historical +EV opportunities and helps validate model accuracy. Recreational books cater to casual bettors and often offer worse prices. The gap between sharp and recreational lines is where profitable bettors find consistent edges.

What Historical Closing Line Data Includes

Opening lines
Closing lines (most important for CLV analysis)
Line movements with timestamps
Moneyline, spread, totals
Major sports: NFL, NBA, MLB, NHL, Soccer, Tennis
Game results for settlement validation

Use Cases for Historical Odds Data

1. Backtesting Betting Models

The primary use case. Test your predictive models against historical odds to see if they would have been profitable:

Load historical odds for NBA from 2020 to today
Run your model predictions for each game
Compare model predictions to actual odds available
Calculate ROI if you had bet based on model

Pitfall to Avoid: Don't backtest against opening lines only: you need to know what odds were available when your model would have actually made the bet.

2. Closing Line Value Analysis

Measure your betting performance by comparing your bet prices to closing lines:

Track all your bets with the odds you got
Compare to Pinnacle closing line
Calculate CLV% for each bet
Positive CLV = beating the market (good!)

Example: You bet Lakers -5.5 at -110. Pinnacle closes at -6.5. You beat closing by 1 point (positive CLV).

3. Line Movement Studies

Analyze how odds move from opening to closing to identify sharp action:

Track opening vs. closing line differences
Identify "steam moves" (rapid line changes)
Correlate line moves with bet timing
Find patterns in sharp betting

4. Arbitrage Backtesting

Find historical arbitrage opportunities to validate arb strategies:

Compare odds across multiple books historically
Identify when arb opportunities existed
Calculate historical arb profitability
Determine which sportsbook pairs create most arbs

5. Market Efficiency Research

Academic and professional analysis of betting market behavior:

Test efficient market hypothesis in sports betting
Analyze favorite-longshot bias
Study home field advantage pricing over time
Quantify market reaction to news/injuries

6. Sportsbook Comparison

Determine which sportsbooks historically offer the best value:

Compare average odds across books for specific bet types
Identify books that consistently offer better prices
Find books with soft lines in specific sports/markets

Historical Data Availability by Sport

Sport	Typical Historical Depth	Pinnacle Available	Data Quality	Notes
NFL	5-10 years	✅ Excellent	⭐⭐⭐⭐⭐	Most complete data available
NBA	5-10 years	✅ Excellent	⭐⭐⭐⭐⭐	Includes player props historical
MLB	5-10 years	✅ Excellent	⭐⭐⭐⭐⭐	Most extensive dataset
NHL	3-7 years	✅ Good	⭐⭐⭐⭐	Good coverage, fewer props
Soccer	3-7 years	✅ Good	⭐⭐⭐⭐	Varies by league
College Sports	2-5 years	❓ Limited	⭐⭐⭐	Less consistent coverage
MMA/Boxing	2-5 years	✅ Good	⭐⭐⭐	Major events well-covered
Tennis	3-5 years	✅ Good	⭐⭐⭐⭐	Grand Slams excellent

Historical Odds Pricing

Historical odds data is typically more expensive than current odds because:

Storage Costs: Years of data requires significant database infrastructure
Acquisition Difficulty: Historical data often comes from scraping over many years
Licensing: Some providers pay for official historical data rights
Higher Value: Critical for professional bettors willing to pay premium prices

Typical Pricing Models

Per-Sport Licensing: $200-500/month per sport for multi-year history
Historical Add-On: $100-300/month added to current odds subscription
Bulk Data Dumps: One-time purchase of CSV/JSON historical files ($500-2000)
API Access: Query historical odds via API (higher monthly fees)

Free Options: Some providers offer 30-90 days of historical data in their lower-tier paid plans (starting ~$50/month). For longer history (years of data), expect $200+/month.

Frequently Asked Questions

Where can I get free historical odds data?

Free historical odds data is very limited. Some providers include limited historical data (past 30-90 days) in their free tiers. Sports-Reference.com offers basic closing lines for major sports going back years (free with registration). For comprehensive historical databases with Pinnacle/Bet365, you'll need paid access.

What is Closing Line Value (CLV)?

Closing Line Value measures the difference between the odds you bet at and the closing odds (final odds before game starts). If you consistently bet at better prices than closing, you're beating the market. Example: You bet Lakers -5 (-110), line closes at -6 (-110). You gained 1 point of CLV. Pinnacle closing lines are the gold standard for CLV calculation.

How far back does historical Pinnacle data go?

Most third-party providers offer Pinnacle historical data from 2018-present. Some specialized providers have older data, but pre-2018 data is harder to find. Pinnacle itself closed its public API in July 2025.

Can I backtest betting strategies with historical odds?

Yes, this is the primary use of historical odds APIs. To properly backtest: (1) Get historical odds data with timestamps, (2) Run your model's predictions for past games, (3) Determine which odds would have been available when your model made each prediction, (4) Calculate P&L assuming you bet those odds. Never backtest using only opening or closing lines: use the actual odds available at decision time.

What's the difference between opening and closing lines?

Opening lines are the first odds posted by sportsbooks (often Sunday night for NFL). Closing lines are the final odds right before the game starts. Closing lines are more accurate because they incorporate all betting action, sharp money, and late information. For backtesting, closing lines are more important.

Do historical odds APIs include player props?

Some do, but historical player props data is much more limited than game odds. A few providers include historical player props for NBA, NFL, and MLB going back 2-3 seasons. Expect to pay premium prices ($300+/month) for comprehensive historical props databases.

Why are Pinnacle lines considered the "sharpest"?

Pinnacle accepts professional bettors (unlike most sportsbooks that limit or ban winners), has very high betting limits, and uses sophisticated pricing models. This means Pinnacle's lines reflect true market consensus from sharp bettors. Other books often copy Pinnacle's lines because they're so accurate.

Can I download historical odds as CSV files?

Some providers offer bulk historical data downloads in CSV or JSON format. This is often cheaper than API access if you only need a one-time historical dataset. Expect to pay $500-2000 for multi-year, multi-sport CSV dumps.

Compare the providers side by side in the SportsAPIs.dev directory. For lines on the closed Pinnacle API, see the Pinnacle API guide.