SportAPI
API integration

Tennis Match Statistics in JSON: Aces, Double Faults and Break Points From a Live API

What a live tennis API returns in JSON: the score by sets, games and points, eight serve statistics per player, and sub-events for aces, double faults and breaks, with code to read them.

A JSON window with live tennis statistics, cards for aces, double faults and break points, a ball and a racket on the court

A live tennis API gives you three levels of score at once, sets, games and points, and a short block of serve statistics for each player: aces, double faults, first-serve percentage, points won on first and second serve, break points converted, breaks. All of it arrives as JSON in the same match object as the odds, so one request feeds a scoreboard, a stats panel and a bet slip.

We checked this on 4 November 2026 on a test key, during the ATP Paris match Alexander Zverev v Lorenzo Musetti. The events list for tennis returned 54 live matches, and the match object carried score_full: "0:0" for sets, score_period: "1:1" for games, score_extra: "40:0" for points, period_name: "1st set" and a stat_list of eight statistics. The same match had sub-events named Aces, Double Faults and Breaks with their own markets. Below is what each field means, how to read it in code, and what the feed doesn’t give you.

The data comes from Sport Line API, the SportAPI odds and live data feed; tennis is sport 4 in it. The product page for the sport is the Tennis Odds API.

Why tennis is harder to display than a football score

A football match has one score and a clock. A tennis match has a score inside a score inside a score, and no clock at all:

LevelWhat changesField in the APIExample
SetsOnce every 30–60 minutesscore_full"1:0"
Games in the current setEvery few minutesscore_period"5:1"
Points in the current gameEvery rallyscore_extra"40:0"
Which set is onAt the end of a setperiod_name"2nd set"

The timer field is 0 for tennis: there’s no match clock, so an interface that shows minutes played is wrong by design. Serve alternates every game, a set can end in a tie-break, matches are best of three or best of five, and a player can retire in the middle of a set. A feed that only gives “1:0” is useless for a live page; a feed that gives all three levels but without a stable structure is a pain to parse. The structure below is stable across matches: the same three fields, the same string format.

Where live tennis statistics come from

Statistics live in the stat_list array of a live match, and they’re returned in two places: inside every match of the live list and inside the detailed match object.

GET /v1/events/4/0/sub/50/live/en
GET /v1/event/{gameId}/group/live/en

The paths are relative to the API domain that the manager issues together with the key; the key goes into the Package header. The first request returns all live tennis matches grouped by tournament. If you don’t need odds, add ?odds=false and the response shrinks 2 to 5 times, which matters when you poll every 7 seconds. The second request returns one match with the full market list and the sub-events.

This is the real stat_list from the Zverev v Musetti match, early in the first set:

"stat_list": [
  { "id": 1,  "name": "Aces",                "opp1": "1",   "opp2": "1"  },
  { "id": 2,  "name": "Win % 1st Serve",     "opp1": "100", "opp2": "67" },
  { "id": 3,  "name": "Break point %",       "opp1": "0",   "opp2": "0"  },
  { "id": 4,  "name": "Double faults",       "opp1": "0",   "opp2": "1"  },
  { "id": 7,  "name": "Win % 2nd Serve",     "opp1": "100", "opp2": "67" },
  { "id": 8,  "name": "1st Serve %",         "opp1": "50",  "opp2": "50" },
  { "id": 30, "name": "Points on own serve", "opp1": "4",   "opp2": "4"  },
  { "id": 98, "name": "Breaks",              "opp1": "0",   "opp2": "0"  }
]

Three rules for reading it. Values are strings, even the numbers, so convert them before you compare or draw bars. opp1 always belongs to opp_1_name and opp2 to opp_2_name: if your interface swaps the players, swap the values with them. And use id for logic, because name is localized: request the match in another language and Aces becomes a different word while id: 1 stays.

idStatisticTypeHow to show it
1Acescountnumber per player
4Double faultscountnumber per player
81st Serve %percentbar, first serves in
2Win % 1st Servepercentbar, points won on first serve
7Win % 2nd Servepercentbar, points won on second serve
30Points on own servecountnumber per player
3Break point %percentbar, break points converted
98Breakscountnumber per player

Statistics exist only while the match is live. Prematch objects have no stat_list, and when the match leaves the live line the statistics leave with it. If you want the final numbers after the match, save them from the last live response yourself. Not every live match carries statistics either: the documentation’s saved snapshot had them for 16 of 39 matches across sports, so treat an empty stat_list: [] as “no stats for this match”, not as an error.

Reading the score: sets, games and points in code

The three score strings follow one format, "left:right", so a formatter is a few lines:

// score_full: sets, score_period: games in the current set, score_extra: points in the current game
function tennisScore(match) {
  const [sets1, sets2] = match.score_full.split(':');
  const [games1, games2] = (match.score_period || '0:0').split(':');
  const points = match.score_extra || '';  // "40:0" during a game, "0:0" or "" between games
  return {
    sets: `${sets1}-${sets2}`,
    games: `${games1}-${games2}`,
    points,
    set: match.period_name,                // "1st set", "2nd set", ...
    stats: Object.fromEntries(
      (match.stat_list || []).map((s) => [s.id, [Number(s.opp1), Number(s.opp2)]]),
    ),
  };
}

// { sets: "0-0", games: "1-1", points: "40:0", set: "1st set", stats: { 1: [1, 1], 4: [0, 1], ... } }

Two things the response doesn’t contain, so don’t invent them. There’s no field for who is serving: if your layout needs a serve marker, you’ll have to track it yourself from the game count, and a tie-break breaks that rule. And there’s no completed-set breakdown in the live object; score_full is the set count, not the games of each finished set. The per-set games arrive in the results feed after the match (more on that below).

Poll the live list every 7 seconds at most and a single match every 5. Between requests, the point score changes faster than that, which is normal: show what the last response said and don’t animate a timer, because there isn’t one.

Aces, double faults and breaks as sub-events

The detailed match object has a sub_games array. For the match we checked it listed 11 sub-events, each with its own game_id:

1st set · 2nd set · Quick events · Quick events,1st set
Aces · Aces,1st set · Double Faults · Double Faults,1st set
Breaks · Breaks,1st set · Breaks,2nd set

A sub-event is a separate match object in the API. Request it with the same event method and you get its own markets and its own score. For the Aces sub-event the score is the ace count itself: at that moment score_full was "1:1", one ace each, and the markets were totals over the match and per player, Over 4.5, 9.5 and 14.5 with Total 1 and Total 2 for each player:

// stat sub-events are found by name; each one is fetched like a match
const statSubs = match.sub_games.filter((s) =>
  /^(Aces|Double Faults|Breaks)$/.test(s.game_name),
);
for (const s of statSubs) {
  const sub = await fetchLine(`/v1/event/${s.game_id}/group/live/en`, 5_000);
  // sub.score_full: the current count, e.g. "1:1" aces
  // sub.game_oc_list: totals for the match and per player
  // sub.game_mid: points back to the main match
}

This is where statistics and betting meet. The stat_list number tells the reader how many aces have been served; the sub-event’s market tells them what the line expects for the whole match. A tennis stats page that shows “Aces: 7 / Over 14.5 at 1.36” next to each other is built from exactly these two objects. The game_mid field of a sub-event points back to the main match, so you can group everything on one page.

Three things to build with live tennis data

A live stats panel for a tennis site. Poll events for sport 4 with ?odds=false every 7 seconds, render the three score levels and the eight statistics as bars. One backend poller serves every visitor from a cache; the API key stays on the server. The match tracker widget supports tennis and is available for a match when zp is populated; in the Paris match it was.

Inputs for a win-probability model. People search for a “tennis win probability API”, and the feed doesn’t return probabilities. It returns two things a model needs: live serve statistics and the current odds. A two-way market with the margin removed gives a baseline, and your model adjusts it with the stats:

def implied_probability(k1: float, k2: float) -> tuple[float, float]:
    """Two-way market: remove the bookmaker margin proportionally."""
    p1, p2 = 1 / k1, 1 / k2
    total = p1 + p2            # above 1 because of the margin
    return p1 / total, p2 / total

implied_probability(1.304, 3.57)   # (0.73, 0.27): Zverev v Musetti at 1-1 in the first set

The odds 1.304 and 3.57 are the W1 and W2 selections of the 1x2 market in the same response; tennis has no draw, so the market has two columns. How to go from a baseline to a trained model is in our article on building a prediction model in Python; the approach is the same for tennis with serve statistics as features.

Alerts. A break of serve, a tie-break, a third set: each is a change in a field you already poll. Breaks moving from 0 to 1, score_period reaching 6:6, period_name becoming 3rd set. The polling loop and the Telegram delivery are described in the live signals bot article; the tennis-specific part is just the condition.

Fixtures before the match and results after it

The live feed is one of three sources, and they don’t overlap:

WhenWhat you getWhere
Before the matchTournaments, participants, start time, prematch marketsevents with line; the match calendar /v1/events/4/0/sub/50/line/{hours}/{days}/en for today, tomorrow or the next few hours
During the matchScore by sets, games and points, stat_list, live markets, sub-eventsevents and event with live
After the matchFinal score by sets and the games of each setSports Results API, from $25 a month for one sport, +$10 per extra language

Two details for the fixtures side. Doubles come with opp_1_ids and opp_2_ids arrays, two participant IDs per side, while the names stay in opp_1_name and opp_2_name. And a match gets a new game_id when it moves from prematch to live, so link your prematch and live records by participants and start time, not by ID.

Detailed historical player statistics, head-to-head records and season averages are not in the live feed and not in the results feed. A separate statistics API for that is in development; ask the manager about it rather than scraping ranking sites.

What the feed does not give you

  • Statistics for prematch or finished matches. stat_list exists only in live. Store the last live values if you need them later.
  • A serve indicator. There’s no field for the serving player.
  • A match clock. timer is 0 for tennis.
  • Win probabilities. Compute them from odds and statistics on your side.
  • Guaranteed statistics for every match. Lower-level tournaments may come without stat_list; check length before rendering.
  • A push channel. WebSocket is in development; production integrations poll at the documented intervals.

Mistakes that break tennis pages

  1. Treating score_full as games. It’s sets. Games are in score_period.
  2. Comparing opp1 as a string. "100" > "67" is a string comparison; convert first.
  3. Matching statistics by name. Names are localized. Match by id.
  4. Polling event for all 54 matches. Request details only for the match someone opened; the list already carries stat_list.
  5. Linking prematch and live by game_id. They’re different IDs. Use participants and start time.
  6. Showing a timer. It’s always 0.

How to check it on today’s matches with SportAPI

A test key gives two days of access to all sports, prematch and live, so the whole check fits in one session:

  1. GET /v1/menu/live/en and confirm sport 4 is in the list with a non-zero counter.
  2. GET /v1/events/4/0/sub/50/live/en?odds=false and pick a match whose stat_list isn’t empty.
  3. GET /v1/event/{gameId}/group/live/en, read the three score fields, the statistics and sub_games.
  4. Request the Aces sub-event by its game_id and compare its score_full with stat_list entry id: 1.
  5. Poll the match for a few minutes and watch score_extra move.

Live statistics, sub-events and the tennis line are included in the plan for one sport, from $30 a month. The Tennis Odds API page lists the markets; the live statistics data model in the documentation describes stat_list for every sport.

FAQ

Is there a free tennis statistics API?

Not as a permanent plan. SportAPI gives a free test key for two days with all sports and live data, which is enough to build and check a tennis page. After that the plan for one sport starts at $30 a month.

Does the API say who is serving?

No. The live object has the score at three levels and the statistics, but no serve marker. If you need one, derive it from the game count and handle tie-breaks separately.

Can I get aces and double faults for a finished match?

Not from the results feed, which returns the score by sets and games. Statistics are available while the match is live, so save the last live values if you need them afterwards. Detailed historical statistics are a separate product in development.

Which tournaments are covered?

In our checks the live list included ATP, WTA and Challenger events. Coverage changes with the calendar, so check the tournament you need through menu on a test key before promising it to users.

Does the feed return win probabilities?

No. It returns the odds, from which you can compute an implied probability, and the live statistics you can feed into your own model.

Is the tennis data available in other languages?

Yes. The language code in the URL changes name in stat_list, period names and market names. Statistic IDs and the score strings stay the same.

What to check before you connect

Open a live match on a test key today and look at four things: the three score fields update as the points go, stat_list has the eight statistics, the Aces sub-event’s score matches the aces count, and the match you need is in menu. If all four pass, the tennis page is a day of front-end work on top of the polling loop. Ask the SportAPI manager on Telegram for the key and run the check on tonight’s matches.

← All articles