Real-time cricket data for developers

Live Cricket Scores API for Ball-by-Ball Match Updates

Add live cricket scores, innings data, ball-by-ball events, wickets, boundaries, partnerships and match status to your website, mobile app or data product through a developer-friendly Cricket API.

REST API WebSocket Streaming Structured JSON
Live Score Ball-by-Ball Match Status
{
  "match_id": "match_84219",
  "status": "live",
  "format": "T20",
  "innings": 2,
  "batting_team": "Lahore",
  "score": "148/4",
  "overs": 16.2,
  "target": 181,
  "last_event": "FOUR",
  "required_run_rate": 8.68
}
Request Data REST Retrieve live matches on demand
Stream Events WebSocket Receive continuous match updates
Live cricket data in one integration

What Is a Live Cricket Scores API?

A Live Cricket Scores API gives applications structured access to matches that are currently in progress. Instead of collecting scores manually or attempting to extract information from public scoreboards, your application can request or receive machine-readable match data and present it in its own interface.

The API can support scorecards, match centres, live tickers, fantasy dashboards, notification systems, media websites, analytics tools and other products that need current cricket information. REST endpoints are suitable for scheduled requests, while WebSocket delivery can be used for experiences that need a continuous stream of live events.

Exact competitions, fields, update methods and historical availability depend on the selected plan and confirmed API coverage.

Live Score Data Available to Your Application

Current Scores

Display runs, wickets, overs, innings totals, targets and the current state of play.

Ball-by-Ball Events

Process deliveries, runs, extras, wickets, boundaries and other match events as data.

Match Status

Identify scheduled, delayed, live, innings-break, interrupted, completed or abandoned matches.

Players at the Crease

Show current batters, active bowler, individual figures and partnership information where available.

Required Match Context

Use targets, run rates, required rates, toss details, venues and competition information.

Results and Outcomes

Update match pages with final scores, winning team, result text and completed scorecards.

REST API vs WebSocket for Live Cricket Scores

Both delivery methods can be useful in the same product. REST is straightforward for retrieving current state, while WebSocket streaming is better suited to interfaces that must react as live events arrive.

Requirement REST API Live Delivery
WebSocket
How data is received Your application requests data or listens for pushed events Request and response Persistent event stream
Best suited to Common implementation patterns Fixtures, score refreshes, match pages and initial state Live scoreboards, tickers, alerts and event-driven interfaces
Application responsibility Work performed by your integration Choose an appropriate polling interval Maintain connection and process incoming events
Recovery pattern Handling refreshes or interrupted connections Request the latest match state again Reconnect, then reconcile with current REST state
Recommended approach Production integration strategy Use as the source of current state Use for incremental live updates

Build a Reliable Live Match Experience

A production integration should do more than display a score string. It should preserve match state, process changes safely and recover cleanly when a user refreshes the page or a network connection is interrupted.

Load the latest match state when the screen opens
Store stable match, team and player identifiers
Apply new events in chronological order
Avoid counting the same delivery or event twice
Reconnect safely after temporary network loss
Respect documented authentication and rate limits
Suggested Flow
1. Request active matches
2. Load the selected match state
3. Render scorecard and match context
4. Subscribe to live events
5. Apply each event once
6. Reconcile after reconnection
7. Store the final result

Recommended Data Checks

Validate the match identifier
Check the event timestamp or sequence
Confirm innings and over context
Handle delayed or corrected events
Show a last-updated indicator
Keep a graceful fallback state
Integration examples

Request Live Cricket Scores in JavaScript, Python and PHP

The examples below demonstrate a common authenticated REST request pattern. Replace the example base URL, endpoint and authentication header with the values provided in the final API documentation.

// JavaScript
const response = await fetch(
  'https://api.example.com/v1/cricket/matches/live',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Accept': 'application/json'
    }
  }
);

if (!response.ok) {
  throw new Error(`API error: ${response.status}`);
}

const data = await response.json();
console.log(data);
# Python
import requests

url = 'https://api.example.com/v1/cricket/matches/live'
headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Accept': 'application/json'
}

response = requests.get(
    url,
    headers=headers,
    timeout=15
)

response.raise_for_status()

data = response.json()
print(data)
<?php
$url = 'https://api.example.com/v1/cricket/matches/live';

$ch = curl_init($url);

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Accept: application/json',
    ],
    CURLOPT_TIMEOUT => 15,
]);

$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);

curl_close($ch);

if ($status >= 200 && $status < 300) {
    $data = json_decode($body, true);
}

Example Live Match Response

This illustrative response shows the type of match context a live-score product may consume. The final field names and nesting must follow the published API documentation.

{
  "data": {
    "match_id": "match_84219",
    "competition": {
      "id": "competition_91",
      "name": "National T20 League"
    },
    "format": "T20",
    "status": "live",
    "venue": "Central Cricket Ground",
    "innings": {
      "number": 2,
      "batting_team_id": "team_18",
      "score": 148,
      "wickets": 4,
      "overs": "16.2",
      "target": 181,
      "current_run_rate": 9.06,
      "required_run_rate": 8.68
    },
    "current_players": {
      "striker_id": "player_301",
      "non_striker_id": "player_447",
      "bowler_id": "player_112"
    },
    "last_event": {
      "event_id": "event_991827",
      "over": "16.2",
      "type": "boundary",
      "runs": 4
    },
    "updated_at": "2026-08-01T10:31:22Z"
  }
}
Commercial applications

What Can You Build With a Cricket Live Score API?

Live Score Websites and Match Centres

Create match pages with current innings totals, ball-by-ball timelines, player figures, partnerships, targets, results and related competition information.

Fantasy Cricket Applications

Use live match events and player performance data to update points, contests, player cards, leaderboards and in-app match views.

Sports Media and Publishing Platforms

Enhance articles, live blogs and tournament pages with embedded scoreboards, fixtures, results and structured match information.

Sportsbooks and Betting Products

Combine live match state with separately available odds and market data to support trading views, event context and customer-facing interfaces.

Notifications and Alerting Systems

Trigger application notifications for wickets, milestones, innings changes, match starts, results and other selected events.

Cricket Analytics Dashboards

Track run rates, partnerships, scoring phases, bowling spells and other live indicators alongside historical statistics.

Live Cricket Match Lifecycle

Applications should treat match status as structured data rather than assuming every scheduled match moves directly from upcoming to live and then completed. Weather, venue conditions, administrative decisions and revised schedules can affect the lifecycle.

Status category What it may mean Recommended interface behaviour
Scheduled Match is listed but has not started. Show start time, teams, venue and pre-match information.
Delayed The expected start has been postponed. Display the latest status and avoid showing the match as live.
Live Play is in progress and match events are updating. Show the score, innings context and a clear live indicator.
Innings Break One innings has ended and the next has not started. Show the completed innings, target and next-innings context.
Interrupted Play has temporarily stopped after starting. Preserve the score and explain that play is suspended.
Completed The match has ended with a recorded outcome. Replace live indicators with the result and final scorecard.
Abandoned or Cancelled The match will not continue or did not begin. Show the official status without inventing a result.
Integration quality

Authentication, Rate Limits and Error Handling

A dependable live-score integration should follow the authentication, request limits and response conventions defined in the API documentation. Keep API credentials on a secure server whenever possible and avoid exposing private keys in public browser code.

Protect API Credentials

Store production credentials in environment variables or a secure secrets system. Route browser requests through your own backend when the API key must remain private.

Handle Request Limits

Use sensible caching, avoid unnecessary duplicate requests and follow any rate-limit headers documented by the API.

Plan for Temporary Failures

Use timeouts, controlled retries and a last-known state so a temporary network issue does not break the entire match interface.

Log Important Context

Record the endpoint, match identifier, response status and request time without logging secret credentials or unnecessary personal information.

Live Cricket Scores API Coverage

Coverage may include international cricket, domestic tournaments and franchise leagues across multiple match formats. Availability can differ by competition, season, endpoint and subscription plan, so verify the competitions and data fields required by your product before launch.

Use the coverage page to review supported competitions and confirm whether your integration needs live scores only, ball-by-ball detail, player statistics, historical data, odds or prediction information.

Frequently asked questions

Live Cricket Scores API FAQs

What data does the Live Cricket Scores API provide?

Depending on coverage and plan, live data may include match status, innings scores, wickets, overs, targets, run rates, current players, partnerships, ball-by-ball events and final results.

Can I receive ball-by-ball cricket updates?

Ball-by-ball events can be delivered through supported endpoints or live streams where available. Confirm the required competition and plan before relying on this data in production.

Should I use REST or WebSocket?

Use REST to retrieve current match state and WebSocket for continuous event updates. Many live applications combine both methods for reliability.

Can I build a fantasy cricket app with this API?

Yes, live match and player data can support fantasy scoring and match views. Your scoring rules, contest logic, compliance requirements and user accounts remain part of your own application.

Does the API include historical cricket scores?

Historical match and performance data may be available through separate endpoints or plans. Review the coverage and pricing information for the depth required by your project.

How do I start integrating?

Choose a suitable plan, obtain an API credential, review authentication and endpoint documentation, test with a small integration and then add caching, error handling and monitoring before production launch.

Start your integration

Add Live Cricket Scores to Your Application

Review the available plans, confirm competition coverage and begin building your live cricket score experience with REST endpoints and real-time delivery options.