Live Tennis API Review 2026

Live Tennis API is a tennis-only sports data API that covers ATP, WTA, Challenger, and ITF across singles and doubles. It goes deeper than scores. You get point-by-point match narratives, match-winner market pricing (bid, ask, and mid with recent tick history), a proprietary win-probability model, and shot-level rally data on charted matches.

The depth is the pitch. General-purpose sports APIs cover tennis as one sport among thirty, with set and game scores and not much else. Live Tennis API treats tennis as its entire product and fills in the layers that generalists skip: individual points, serve directions, rally lengths, and calibrated probabilities that update as the match progresses.

The tour coverage spans all four professional circuits: ATP, WTA, Challenger, and ITF, in both singles and doubles formats. Within each match, the data model goes several levels deeper than a typical scores feed:

• Live scores: sets, games, points, server identity, and tiebreak state, sourced from arbitrated multi-source feeds. The provider quotes no latency figure; each push frame carries a published_at stamp beside the event time so you can measure it yourself.
• Point-by-point history: 30.5 million archived point-state rows across 199,000+ matches from January 2023 to the present (counted November 2026).
• Results archive: 1.48 million ATP and WTA matches going back to 1968.
• Match-winner odds: bid, ask, and mid pricing with tick history (Pro tier and above).
• Win-probability model: a proprietary, calibrated model that returns the favored side, a probability, a confidence score, and the key factors behind the call (Ultra tier).
• Shot-level rally data: 11,600+ charted matches with serve direction, stroke detail, and rally length (Ultra tier).

Player profiles, fixtures, rankings, and tournament schedules round out the non-match endpoints. The historical data archive is one of the deeper tennis-specific collections available through a public API.

The API follows an OpenAPI 3.1 spec, which means you can generate typed clients in any language from the spec file. Live Tennis API also ships first-party libraries:

• Python: livetennisapi with sync and async support, fully typed.
• JavaScript/TypeScript: livetennisapi for Node, Deno, Bun, Workers, and browser.
• MCP server: 24 read-only tools for Claude, Cursor, and other MCP-compatible AI agents (npx livetennisapi-mcp), nine of them on the free plan.
• Postman workspace for manual testing.

The team also publishes an open-source benchmark harness, tennis-api-benchmark (MIT). It measures any API's response time and observed availability from a declared vantage point, and it refuses to print a percentile from fewer than 30 clean samples. It does not measure the delay from the court to your app, and its README says so. Point it at a trial key before you pay for any feed, tennis or not.

Authentication uses either a Bearer token or an X-API-Key header, your choice. The base URL is https://api.livetennisapi.com/api/public/v1. Responses are JSON with UTC timestamps throughout.

The MCP server is a genuine differentiator. If you are building an AI agent that reasons about live tennis matches, the server gives your model structured access to scores, fixtures, and player data without writing custom integration code. See our sports MCP servers page for context on which providers offer this.

Four tiers, all published, with annual discounts that save two months:

• Free, $0: live scores, current matches, player data, usage tracking. 30 requests/minute, 100/day. No card required.
• Basic, $9.99/mo ($99/yr): historical results, point-by-point match narratives. 60/minute, 1,000/day.
• Pro, $29.99/mo ($299/yr): match timelines, betting market odds, bulk history downloads. 300/minute, 10,000/day.
• Ultra, $99.99/mo ($999/yr): win-probability model, WebSocket push, live statistics, shot-level rally data. 600/minute, 500,000/day.

The free tier is a real free tier, not a trial. You can run it indefinitely for lightweight score tracking. The jump from Free to Basic at $9.99 unlocks the historical archive, which is the data most models actually need. Pro adds the odds layer. Ultra adds the AI-facing features (probability model, WebSocket, rally charting).

SportsAPIs readers get 10% off any paid plan when signing up through our link. Upgrades are prorated mid-cycle, and you can cancel anytime.

Getting a key needs no sales call and no card. Start from our link, open the free-key form at /subscribe/free and type one thing: your email. Verify it and the key is yours, with no end date on the Free plan (checked November 2026). Keys start with twjp_.

Paid plans upgrade that same key, so your code and base URL stay put when you move from Free to Basic or Ultra. If you'd rather buy through a marketplace, the API is also sold on RapidAPI, Apify and API.market. For a quick look in a browser, the docs accept the key as ?token= in the URL, though they say a header is the better choice for anything automated. A wrong key returns 401. An endpoint above your plan returns 403 with upgrade_required and names the plan you need, so your code can tell the two apart.

The sample asks GET /matches for the matches in play, with the key in the X-API-Key header (from the docs, checked November 2026). It runs on the Free plan and costs one of your 100 daily calls.

import os
import requests

resp = requests.get(
    "https://api.livetennisapi.com/api/public/v1/matches",
    headers={"X-API-Key": os.environ["LIVE_TENNIS_API_KEY"]},
    params={"status": "live", "limit": 5},
    timeout=10,
)
resp.raise_for_status()
body = resp.json()
print("live matches returned:", body["meta"]["count"])
for match in body["data"]:
    sets = (match["score"] or {}).get("sets")
    p1, p2 = match["players"]["p1"]["name"], match["players"]["p2"]["name"]
    print(match["tournament"], p1, "v", p2, sets)

List endpoints answer with data and meta. Each match carries tournament, the two players under players.p1 and players.p2, and score.sets. Scores are player-major, so [1, 0] means player 1 leads by a set. When nothing is live, set status to upcoming instead.

The per-minute and per-day caps in the plan list above apply per key. Every response carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset for the minute window. GET /usage shows today's calls, what's left of the day and a 30-day history, and checking it costs no quota. Go over and you get a 429 with Retry-After: the body says rate_limited for the minute, or adds scope: "day" and a resets_at time for the day. Refused calls don't spend the daily allowance (checked November 2026).

The plain-HTML reference covers all 49 operations without JavaScript, with the OpenAPI 3.1 file beside it in YAML and JSON. A dated changelog logs every spec change, additive only within v1. Beside the Python and JavaScript clients, the PyPI package runs on Python 3.9 and up, and a command-line tool runs with no install: npx livetennisapi live. We found no status page, but GET /health answers without a key. Support runs through hello@livetennisapi.com and a Discord server.

The audience is narrow by design, and that narrowness is the strength:

• Tennis betting models that need point-level data, match-winner pricing, and a win-probability signal to build or validate predictions.
• Live-betting tools that push score updates and probability shifts to users in real time via the WebSocket feed.
• Tennis media and stats sites that want deep match narratives, rally breakdowns, and historical archives to power content.
• AI agents and LLM applications that can connect to the MCP server for structured tennis data without custom API wrappers.

If tennis is one sport among many in your product, Live Tennis API pairs well with a general-purpose sports data API from the directory. The generalist covers tennis at the set-and-game level alongside 20+ other sports, and Live Tennis API adds the point-level depth on top.

A multi-sport data provider covers tennis as a line item. You get set scores, maybe game scores, and a winner. Live Tennis API starts where generalists stop: individual points, serve directions, rally lengths, and a trained probability model.

The tradeoff is obvious. You get one sport. If your product covers only tennis, that is not a tradeoff at all. If your product covers ten sports and tennis happens to be one, you will integrate Live Tennis API alongside a broader provider, and you pay for both.

On the odds side, the match-winner pricing is useful for modeling but thin compared to a full odds aggregator. You get bid/ask/mid on the match-winner market. You do not get spreads, totals, set betting, or prices from named bookmakers. For deeper odds coverage on tennis matches, pair this with a provider from the odds API directory.

Live Tennis API is the deepest tennis-specific data feed we have reviewed. Point-by-point archives, a calibrated probability model, shot-level charting, and an MCP server for AI agents add up to a product that takes its single sport seriously. The pricing is accessible (free to start, $9.99 for history, $29.99 for odds) and the developer experience is modern: OpenAPI spec, typed clients, flexible auth.

The limits are the limits of specialization. One sport, no broad odds aggregation, and the richest features (WebSocket, probability, rally data) sit on the $99.99 Ultra tier. For tennis-focused projects, it is hard to argue with the depth. Grab the free tier and pull a live match to see the data model before you choose a paid plan.

What stood out when we vetted Live Tennis API for the directory:

• Tennis-only depth: ATP, WTA, Challenger and ITF, singles and doubles, from live points to completed-match history
• Point-level live scores plus match-winner market prices (bid/ask/mid with recent tick history) over REST and WebSocket
• Proprietary win-probability model, a published OpenAPI spec, and first-party Python/JS clients plus an MCP server for AI agents

A focused tennis feed that goes well beyond scores. The point-by-point WebSocket, match-winner pricing and calibrated win-probability model are exactly what live-betting and prediction-market tools reach for, and the developer experience is refreshingly modern: an OpenAPI spec, official Python and JS libraries, even an MCP server for LLM agents. A free tier covers live scores, paid plans start at $9.99/mo, and readers get 10% off through our link.

Last reviewed: 2 November 2026 · How providers get listed