Snooker, Table Tennis, Darts and Cricket Results in JSON, Without Scraping Federation Sites
Where to get snooker, table tennis, darts and cricket results and live scores in JSON: why hidden federation-site JSON is a poor source, and how these sports look in SportAPI data.

Developers who need snooker, table tennis, darts or cricket results usually take the same route. They open a federation or stats website, find the hidden request in the browser’s developer tools that returns JSON, and start scraping it. It works for a week. Then the site changes the request URL, adds bot protection or stops serving data without cookies, and everything breaks in the middle of a tournament.
A more reliable route is an API built for developers. In SportAPI these sports are covered by two products: the Sports Results API returns final results of completed matches (from $25 a month per sport, plus $10 for each extra language), and the sports odds API returns fixtures and live scores (from $30 a month). Below you’ll see what the data looks like for each sport, Python code to parse it, and the mistakes people run into most often.
Why a federation site’s hidden JSON is a poor source
The internal JSON a site serves to its own pages isn’t an API. It has no documentation, no contract and no obligations to you. The URL and format change without notice: the site updates its layout and your scraper gets an empty response or renamed fields. Frequent requests from one address get blocked by bot protection. Many sites explicitly forbid automated data collection, which is a legal risk for a commercial project.
There’s a practical problem too: one source covers one sport. A table tennis federation site won’t give you snooker, and a snooker stats site won’t give you darts. Four sports means four scrapers, each breaking in its own way.
If you need results for a website, an app, a channel or checking predictions, a single official source is simpler and cheaper to maintain.
What data is available for these sports
We checked live data with a trial key on 24 October 2026. Each sport has its own score format:
| Sport | sport_id | What score_full holds | What else live data includes |
|---|---|---|---|
| Snooker | 30 | Frames: 5:4 | Points per frame in score_period: 15:67;84:2;…, current frame in period_name |
| Table tennis | 10 | Sets: 1:0 | Points per set in score_period: 15:13;4:5, current set, server in pitch |
| Darts | 21 | Legs or sets: 2:4 | Points left in the current leg in score_extra: 501:501 at the start of a leg |
| Cricket | 66 | Each team’s runs: 154:90 | Wickets and overs, innings, batting side |
The competitions follow the calendar. During our check, live data included the Northern Ireland Open in snooker, the Modus Super Series in darts and dozens of simultaneous table tennis matches from the Masters series, Pro League, Setka Cup and WTT events. The menu method gives the current list, and all sport IDs are in the sports reference.
Live scores and final results: which product does what
| Task | Product |
|---|---|
| Tournament and match schedules | Sports odds API, prematch |
| The score during the match: frames, sets, legs | Sports odds API, live |
| Final score of a completed match and the score by period | Sports Results API |
| A results archive for statistics and models | Sports Results API, 20 years of history |
| Settling bets from results | Coupon API, a separate service from $300 a month |
In the Sports Results API a result appears 1–20 minutes after the match ends, and top matches appear immediately. Data is grouped by sport, country and championship, so you can pull, for example, every match of a table tennis series for a day with one filter.
If you need results to settle bets, that’s a different task: you need market rules, voids and cancellations, not just the score. We covered it in our article on final match results for bet settlement.
Code: parsing four sports’ scores in Python
This example takes live matches from the odds API and turns each sport’s score into one clear format:
import requests
API = "https://YOUR_API_DOMAIN/v1/events/{sport}/0/sub/50/live/en?odds=false"
HEADERS = {"Package": "YOUR_API_KEY"}
SPORTS = {30: "snooker", 10: "table_tennis", 21: "darts", 66: "cricket"}
def pairs(text):
"""'15:67;84:2' -> [(15, 67), (84, 2)]"""
result = []
for part in filter(None, (text or "").split(";")):
a, b = part.split(":")
result.append((int(a), int(b)))
return result
def normalize(sport, game):
home, away = (int(x) for x in game["score_full"].split(":"))
item = {
"id": game["game_id"],
"sport": SPORTS[sport],
"players": [game["opp_1_name"], game["opp_2_name"]],
"score": [home, away],
"period": game["period_name"],
}
if sport in (30, 10): # snooker: points per frame; table tennis: per set
item["periods"] = pairs(game["score_period"])
if sport == 21 and game["score_extra"]: # darts: points left in the current leg
item["remaining"] = pairs(game["score_extra"])[0]
return item
def live(sport):
response = requests.get(API.format(sport=sport), headers=HEADERS, timeout=10)
response.raise_for_status()
return [normalize(sport, g) for t in response.json()["body"] for g in t["events_list"]]
for sport in SPORTS:
for match in live(sport):
print(match)
Here is a snooker match from our check after parsing:
{
"sport": "snooker",
"players": ["Jak Jones", "Scott Donaldson"],
"score": [5, 4],
"period": "10th frame",
"periods": [[15, 67], [84, 2], [78, 8], [42, 67], [33, 78], [60, 57], [9, 79], [64, 28], [73, 44], [30, 43]]
}
The last pair in periods is the current frame: 30:43. For cricket the function returns runs, and wickets and overs are added from their own fields as described in the documentation. Request the live list no more than once every 7 seconds.
Where this is useful
A stats website or app. Snooker, darts and table tennis have loyal audiences who want fast results and clear statistics. Fixtures and live scores come from the odds API; the archive and final results from the Sports Results API.
Checking predictions and training models. Table tennis produces dozens of matches a day, and on that volume you quickly see whether a model works. We showed how to gather data and measure a model’s accuracy in our guide to a football prediction neural network in Python; the approach carries over.
A Telegram channel or bot. Evening snooker and darts results, live frame scores, tournament previews, all without manual input.
Mistakes with niche sports results
- One score parser for every sport. In snooker
score_fullis frames, in table tennis sets, in cricket runs. Parse each sport separately. - Sport IDs from memory. Snooker is 30 and darts is 21. Take IDs from the reference or from
menu, not from popularity tables. - All of table tennis, unfiltered. There are so many matches that an unfiltered feed becomes unreadable. Pick the series you need by tournament ID.
- Treating a prematch
0:0as a result. Before a match starts, score fields hold initial values. Take final results from the Sports Results API. - A “temporary” scraper. A temporary scraper usually lasts until it breaks on finals day.
How much it costs
| What you need | Price |
|---|---|
| Final results for one sport | from $25 a month, plus $10 for each extra language |
| Fixtures and live scores for one sport | from $30 a month |
| Testing before you pay | A 2-day trial |
FAQ
Is there a free snooker or table tennis results API?
SportAPI has no free plan, but there is a 2-day trial. Free sources are usually hidden site JSON that isn’t meant for outside developers and can stop working at any time.
Are major snooker and darts tournaments covered?
During our check on 24 October 2026, the Northern Ireland Open was live in snooker, and the darts line included the Modus Super Series and the PDC World Series. Coverage follows the calendar; the menu method shows the current list.
How quickly do final results appear?
In the Sports Results API, 1–20 minutes after the match ends; top matches appear immediately. During the match, the live score updates in the odds API, which you can request every 7 seconds.
Can I get points for every frame and set?
In live data, yes: for snooker and table tennis the points per period come in score_period. Check on a trial which details the final results include for your sport.
Can this data be used to settle bets?
Settling bets needs market rules, voids and cancellation handling, not just the score. That’s a separate service, the Coupon API, from $300 a month.
What to do today
- Pick the sports and tournaments your project needs.
- Get a trial and run the script from this article on current matches.
- Compare the data with what your scraper returns now, then switch the scraper off.
Tell the SportAPI manager on Telegram which sports you need. You’ll get a trial for match results and SportAPI live scores and can check snooker, table tennis, darts and cricket on real matches.