Every cricket match is a chain of events. A tournament starts. Fixtures get announced. The teams walk out, the toss happens, and the first ball is bowled. Runs pile up, wickets fall, and a scorecard tells the story when it is all over.

A good app needs to follow that same chain. That is exactly what cricket API endpoints are built for. Each endpoint answers one question about the game: which seasons exist, which matches are live, who is in the playing XI, how many runs came off the last over.

This guide walks through every group of cricket API endpoints, explains what each one returns, and shows how to combine them in a real product. If you are choosing a cricket API for developers, whether for a live score app, a fantasy platform or a stats site, this is the map you need.

What Are Cricket API Endpoints?

An endpoint is a URL that returns one specific piece of data. You send a request. The server sends back JSON.

Think of a cricket ground. The ground has many gates. One gate leads to the stands, one to the pavilion, one to the press box. Endpoints work the same way. Each one opens a different part of the cricket data feed.

A well-designed cricket API gives you:

• One endpoint for each kind of data, so you never pull more than you need
• Predictable paths, so you can guess the next URL before you read the docs
• Clean JSON from the cricket data feed that drops straight into your app
• Pagination, so large lists do not slow you down

How Do Cricket API Endpoints Work?

Entity Sport is a cricket API provider, and its Cricket API v2 is a token-secured REST API. Every request starts from the same base URL.

• Base URL: https://restapi.entitysport.com/v2/
• Authentication: pass your access token as ?token=YOUR_TOKEN on every request
• Format: JSON responses
• Pagination: list endpoints accept per_page and paged, so you can load results in pages

A basic call looks like this:

https://restapi.entitysport.com/v2/matches/?token=YOUR_TOKEN&status=live

That one request returns every live match. No extra setup. Swap the path and you open a different gate.

How Do You Get a Token for Cricket API Endpoints?

Every request needs a token. You generate it from your keys.

1. Get your access key and secret key from your Entity Sport dashboard with an active subscription.
2. Send a POST request to /v2/auth/ with access_key and secret_key.
3. Read response.token and response.expires from the reply.
4. Pass the token as ?token= on every other request.

By default the token expires in one hour. Add the extend parameter and the token lasts until your subscription ends. When a token expires, call the auth endpoint again.

curl -X POST “https://restapi.entitysport.com/v2/auth/” \

  -d “access_key=YOUR_ACCESS_KEY” \

  -d “secret_key=YOUR_SECRET_KEY”

The reply uses the same envelope as every other cricket API endpoint. A status field says ok or gives an error. A response field holds the data. For the auth call, that data is the token and its expiry timestamp.

Keep your keys on the server. Never place them in front-end code.

What Are the Main Categories of Cricket API Endpoints?

The Entity Sport cricket API has 27 endpoints across 4 categories. Each category matches a stage of how fans follow the game.

Category	Endpoints	What it covers
Seasons and Competitions	10	Seasons, tournaments, teams, squads, standings, leaderboards
Matches	10	Fixtures, scorecards, commentary, live data, analytics
Players	3	Search, profiles, career statistics
Teams and Rankings	4	Team profiles, team fixtures, ICC rankings

Let us go through them one by one.

Which Cricket API Endpoints Cover Seasons and Competitions?

This is where every journey starts. Before you can show a match, you need to know which tournament it belongs to. These ten endpoints let you browse the cricket calendar and drill into any tournament.

• Seasons /v2/seasons/: lists every season you have access to. Seasons are named by year (2016) or across years (2016-17).
• Season Competitions /v2/seasons/{sid}/competitions: lists the competitions inside a season, with pagination.
• Competitions List /v2/competitions: lists all subscribed competitions. Filter by upcoming, completed or live using the status parameter.
• Competitions Overview /v2/competitions/{cid}/: details of a single competition, including dates, format and category.
• Competition Matches /v2/competitions/{cid}/matches/: scheduled, live and completed matches of one competition.
• Competition Teams /v2/competitions/{cid}/teams/: every team taking part.
• Competition Squads /v2/competitions/{cid}/squads/: the player rosters of all participating teams.
• Competition Standings /v2/competitions/{cid}/standings/: the points table for every round or group.
• Competition Statistic Type /v2/competitions/{cid}/stats/: lists the statistic types available, such as batting and bowling leaderboards.
• Competition Statistic /v2/competitions/{cid}/stats/{stat_type}: returns one leaderboard, for example batting_most_runs, bowling_best_averages or team_total_runs.

The last two work as a pair. Call the statistic type endpoint first to see what is on offer. Then call the statistic endpoint with the type you want. That is how you build an Orange Cap or Purple Cap style leaderboard without calculating anything yourself. The cricket stats API does the maths for you.

Which Cricket API Endpoints Return Match Data?

This is the heart of any cricket API. Fans open an app for the match. These ten endpoints give them everything they want to see.

• Matches List /v2/matches/: matches across all competitions. Filter by status, format, date, time zone, day and session. Use it for your home screen.
• Match Info /v2/matches/{mid}/info: teams, venue, toss, weather, pitch and result.
• Match Scorecard /v2/matches/{mid}/scorecard: the full scorecard with batting, bowling, fall of wickets, umpires, toss and venue.
• Match Live /v2/matches/{mid}/live: the fastest updates for the active innings of a live match. This is the endpoint behind your live score screen and the core of any cricket live score API.
• Match Innings Commentary /v2/matches/{mid}/innings/{inning}/commentary: ball-by-ball commentary for a single innings.
• Match Playing 11 /v2/matches/{mid}/squads: the announced playing XI and squad for both teams.
• Fantasy Match Squad /v2/competitions/{cid}/squads/{mid}: rosters for both teams with player roles and fantasy credits.
• Match Fantasy Points /v2/matches/{mid}/point: fantasy points for every player, calculated from match performance.
• Match Statistics /v2/matches/{mid}/statistics/: Manhattan, worm, partnerships, run types, player vs player, wickets and run rates.
• Match Wagon Wheel /v2/matches/{mid}/wagons/: shot placement for every batting shot, with x, y and z positional data.

A few of these deserve a closer look.

Match Live is built for speed. Poll it for the active innings and you get the latest score, batters and bowlers without downloading the whole scorecard each time.

Match Statistics powers the charts fans love. The Manhattan shows runs per over. The worm shows how the chase is moving. Partnerships and run types add the depth that turns a score app into a stats app.

Match Wagon Wheel gives you the coordinates of every shot. Draw them on a ground and you can show exactly where a batter scores. It is one of the most shared visuals in cricket.

What Do the Player Endpoints Offer?

Fans follow players as much as teams. Three endpoints make up the cricket player stats API and cover the full player profile.

• Player Search /v2/players/: search the full cricket player database by name or country.
• Player Profile /v2/players/{pid}/: birth details, role, batting style and bowling style.
• Player Statistic /v2/players/{pid}/stats: career batting and bowling statistics for every format the player has played.

Use search to power a typeahead box. Use the profile for the player page. Use the statistic endpoint for the career table. Three calls, one complete player page.

What Do the Team and Ranking Endpoints Offer?

The last category covers teams and the official ICC rankings.

• Team /v2/teams/{tid}/: team profile with name, logo, country and team type. You can also search teams by name.
• Team Matches /v2/teams/{tid}/matches: fixtures and results for one team, filtered by match status.
• Teams Player /v2/teams/{tid}/player: the players belonging to a team, split by format.
• ICC Ranking /v2/iccranks/: current ICC rankings for batsmen, bowlers, all-rounders and teams in every format.

The ICC ranking endpoint is a quiet favorite. Rankings pages pull steady traffic, and one call fills the whole page.

How Do You Combine Cricket API Endpoints in a Real App?

Single endpoints are useful. Chaining them is where the real product gets built. Think of it like a batting order. Each endpoint has a role, and they work best in sequence.

Here is the flow for a live score app:

1. Call Matches List with status=live to show what is on right now.
2. When a fan taps a match, call Match Info for teams, venue and toss.
3. Load Match Live for the running score and refresh it during play.
4. Add Match Scorecard for the full batting and bowling card.
5. Add Match Innings Commentary for the ball-by-ball feed.

Here is the flow for a fantasy platform built on a fantasy cricket API:

1. Call Competition Matches to list upcoming fixtures.
2. Use Fantasy Match Squad to show both rosters with roles and credits.
3. Use Match Playing 11 once the teams are announced.
4. Use Match Fantasy Points after play to score every player.

Here is the flow for a stats site:

1. Call Seasons, then Season Competitions, to build your tournament menu.
2. Use Competition Standings for the points table.
3. Use Competition Statistic for the leaderboards.
4. Link every name to a Player Profile page.

Case Scenarios: Cricket API Endpoints in Action

Reading endpoint lists is one thing. Using them is another. Here are three real situations and the calls behind each one.

How Do You Fetch Player Stats for a Single Player?

The situation: you are building a player page for Virat Kohli. A fan searches his name and expects to see his profile and career numbers.

Step 1: find the player ID. Search the player database by name.

GET /v2/players/?search=kohli&token=YOUR_TOKEN

Pick the right player from the results and note the pid. Everything else uses that ID.

Step 2: load the profile. Call the Player Profile endpoint with the pid.

GET /v2/players/119/?token=YOUR_TOKEN

Here is a sample response from the Entity Sport Cricket API documentation:

{

  “status”: “ok”,

  “response”: {

    “player”: {

      “pid”: 119,

      “title”: “Virat Kohli”,

      “short_name”: “Virat Kohli”,

      “birthdate”: “1988-11-05”,

      “birthplace”: “Delhi”,

      “country”: “in”,

      “playing_role”: “bat”,

      “batting_style”: “Right Hand Bat”,

      “bowling_style”: “Right Arm Medium”,

      “fantasy_player_rating”: 9,

      “alt_name”: “Virat Kohli”,

      “nationality”: “India”

    }

  },

  “etag”: “4c1e16dfe29a825005c0b94ae6bc1627”

}

A few fields do most of the work on a player page:

• pid is the key you reuse for every other player call
• title is the name to display
• playing_role, batting_style and bowling_style fill the profile card
• birthdate, birthplace and nationality fill the bio
• fantasy_player_rating is handy if you run a fantasy platform

Step 3: load the career stats. Call the Player Statistic endpoint.

GET /v2/players/119/stats?token=YOUR_TOKEN

This returns career batting and bowling statistics for every format the player has played.

[ADD BEFORE PUBLISHING: paste a real response from the /stats endpoint here, with your dashboard token.]

The result: three calls to the cricket player stats API give you a full player page. Cache the profile, since it rarely changes. Refresh the stats on a schedule.

How Do You Build a Most Runs Leaderboard for a Tournament?

The situation: a tournament is live and your site needs an Orange Cap style table of the top run scorers.

Step 1: find the competition. List live competitions and note the cid.

GET /v2/competitions?status=live&token=YOUR_TOKEN

Step 2: see which leaderboards exist. Call the Competition Statistic Type endpoint.

GET /v2/competitions/{cid}/stats/?token=YOUR_TOKEN

The response groups statistic types into batting, bowling and team. Here is a trimmed sample from the Entity Sport documentation:

{

  “status”: “ok”,

  “response”: {

    “stat_types”: [

      {

        “group_title”: “Batting”,

        “types”: {

          “batting_most_runs”: “Most Runs”,

          “batting_most_runs_innings”: “Highest Individual Score”,

          “batting_highest_strikerate”: “Highest Strike Rates”,

          “batting_highest_average”: “Highest Average”,

          “batting_most_run100”: “Most Centuries”,

          “batting_most_run50”: “Most Fifties”,

          “batting_most_run6”: “Most Sixes”

        }

      }

    ]

  }

}

Step 3: pull the leaderboard. Use the key you want, here batting_most_runs.

GET /v2/competitions/{cid}/stats/batting_most_runs?token=YOUR_TOKEN&per_page=10

The result: one list call, one type call and one stat call to the cricket stats API give you a ready leaderboard. Swap the key to bowling_best_averages or batting_most_run6 and you have a new table with no extra logic.

How Do You Show a Live Match on a Score Screen?

The situation: a match is on and fans want the score right now. This is the classic cricket live score API use case.

Step 1: find what is live.

GET /v2/matches/?status=live&token=YOUR_TOKEN

Step 2: open the match. Use the mid from the list to load the teams, venue and toss.

GET /v2/matches/{mid}/info?token=YOUR_TOKEN

Step 3: start the live feed. Call Match Live and refresh it during play.

GET /v2/matches/{mid}/live?token=YOUR_TOKEN

Step 4: add depth on demand. When a fan taps for more, load the scorecard or the innings commentary.

GET /v2/matches/{mid}/scorecard?token=YOUR_TOKEN

GET /v2/matches/{mid}/innings/{inning}/commentary?token=YOUR_TOKEN

The result: the live screen stays light because it only polls one endpoint. The heavy data loads only when a fan asks for it.

What Should Developers Know Before They Start?

A few habits will save you hours when you work with any cricket API for developers.

• Cache the slow-moving data. Seasons, teams, squads and player profiles change rarely. Store them and refresh them on a schedule.
• Poll only what moves. Match Live is the endpoint for fast updates. Do not poll the full scorecard every few seconds.
• Use pagination. Set per_page and paged on list endpoints so responses stay small.
• Filter at the source. The status, format and date parameters on Matches List stop you from downloading matches you will never show.
• Keep the token on the server. Never ship your access token in front-end code.

For the complete request parameters, response fields and live examples, always check the official cricket API documentation.

Why Choose Entity Sport for Cricket API Endpoints?

Entity Sport is a real-time sports data company and a cricket API provider. The cricket API covers the full match journey, from seasons and competitions to ball-by-ball commentary and advanced match analytics.

Here is what a cricket API for developers should offer, and what Entity Sport delivers:

• 27 endpoints across four clear categories
• Live match data, scorecards and ball-by-ball commentary
• Fantasy cricket API endpoints with squads, credits and points
• Advanced analytics such as the Manhattan, worm and wagon wheel
• ICC rankings for batsmen, bowlers, all-rounders and teams
• A clean, paginated cricket data feed over a token-secured REST API

One API. Every format. From the biggest tournaments to a single match.

To see the full response schemas, read the cricket API documentation for v2. When you are ready to build, grab your API key from the dashboard.

Frequently Asked Questions

What are cricket API endpoints?

Cricket API endpoints are URLs that each return one type of cricket data in JSON. One endpoint gives you live scores. Another gives you scorecards. Another gives you player profiles. You combine them to build your app.

How many endpoints does the Entity Sport cricket API have?

The Entity Sport Cricket API v2 has 27 endpoints. As a cricket API provider, Entity Sport groups them into Seasons and Competitions (10), Matches (10), Players (3) and Teams and Rankings (4).

How do I authenticate with the cricket API?

Pass your access token as a query parameter on every request, like ?token=YOUR_TOKEN. All requests go to the base URL https://restapi.entitysport.com/v2/. The cricket API documentation covers the auth call in full.

Which endpoint should I use for live cricket scores?

Use the Match Live endpoint at /v2/matches/{mid}/live. It returns the fastest updates for the active innings. Pair it with Match Info for the static details and Match Scorecard for the full card.

Can I build a fantasy cricket app with these endpoints?

Yes. These endpoints work as a fantasy cricket API. Fantasy Match Squad gives you rosters with roles and credits. Match Playing 11 confirms the final teams. Match Fantasy Points scores every player from match performance.

Final Thoughts

A cricket match is a story told ball by ball. Cricket API endpoints let you tell that story in your own app. Start with the calendar. Move to the match. Go deep on the player. Each endpoint is a small piece, and together they cover the whole game.

Pick the endpoints your product needs, chain them in the right order, and your fans will feel every run.