For developers, analysts & builders

Live tennis data.
Ready to build on.

Point-by-point scores, prices and win-probability for your next dashboard, model or app. ATP, WTA, Challenger and ITF, through one REST + WebSocket API.

No credit card · 100 requests/day on Free

From $9.99/moJSON · UTC timestampsRead the docs
From the court to your codeExample response
Singles · Hard courtIllustrative match
Player one 6330
Player two4540
GET /matches/18042/scoreJSON

  "sets" 1 0
  "games" 6435
  "points" "30" "40"
  "server" 1
  "is_tiebreak" false
  "win_probability_p1" 0.62
  "timestamp" "2026-07-18T10:41:07Z"


Scores are available on Free. The win-probability field requires Ultra.

Also available on RapidAPI Apify API.market Postman
Your first integration

Go from key
to first response.

  1. 01

    Get your free key

    Verify your email. Keep the same key when you upgrade.

    Create a key
  2. 02

    Make a request

    Try current matches and inspect the returned JSON.

    See the sample request
  3. 03

    Choose what you need

    Match your data fields and daily volume to a plan.

    Find your plan
Choose your starting point

Plans that fit what you build.

Try live scores free. Choose a paid plan for the data and capacity your product needs.

Already have a key? Upgrade your existing key or open your portal.

Free to explore. No card required.

Live scores, current matches, players and fixtures. 100 requests/day · 30/min.

Completed-match history, market odds, model fields and WebSocket are on paid plans.

Explore match history

Basic

$9.99/mo
$8.25/mo
billed annually — $99/yr
1,000 requests/day · 60/min

For results dashboards and match research.

  • Everything in Free, plus:
  • Historical match results (completed matches)
  • Point-by-point match tape, per match

REST access. Market odds start at Pro.

Build with market data

Pro

$29.99/mo
$24.92/mo
billed annually — $299/yr
10,000 requests/day · 300/min

For odds dashboards and data pipelines.

  • Everything in Basic, plus:
  • Match events & timeline
  • Match-winner market odds — live ticks and a per-point price history
  • Bulk history packages (monthly downloads)

REST access. Streaming and model fields are on Ultra.

Stream and model

Ultra

$99.99/mo
$83.25/mo
billed annually — $999/yr
500,000 requests/day · 600/min

For live products and advanced analysis.

  • Everything in Pro, plus:
  • Live streaming push feed (WebSocket) & webhooks
  • AI win-probability & analysis
  • Live in-play match statistics — aces, double faults, serve split, hold/break
Rankings & shot-level research
  • As-of-match rankings (ATP/WTA, ITF, UTR) for backtests
  • Shot-by-shot rally construction — serve direction, every stroke, rally length (11,638 charted matches, both tours, back to 1960)
  • Shot-level serve/return charting stats — serve placement, return depth, net & serve-and-volley, clutch break/game/set-point serving & returning

Cancel renewal anytime — your key returns to Free when the paid plan ends · Upgrade on the same key · Secure checkout with Stripe

Coverage varies by match and data field. Inspect historical coverage and check the API reference before choosing.

A different data need?

Let’s find the right fit.

A History plan adds the point-by-point tape to a free key without changing tier. For custom quotas, licensing or a dedicated feed, tell us what you are building.

Talk through your requirements
See it running

Fifteen minutes of the live board, unedited

Our feed beside a public prediction market, on one clock. The figure at the top is a measured interval — the time between our score commit and the market's next quote move — shown with the number of samples behind it.

The Live Tennis API board: live matches with our score commit beside the market line, each on its own clock.

Open the full recording page

What you get

The building blocks for your tennis product.

Live scores, historical match data, market odds and model outputs. Choose the access your project needs.

01

Live scores, arbitrated

Sets, games, points, server and tiebreak state for every live match — arbitrated from multiple sources into one clean feed.

02

Push-feed streaming

Score updates pushed over WebSocket as each point is scored, on a feed built for fan-out. Subscribe to one match or the whole slate; no polling, no rate-limit juggling.

03

AI win-probability

A proprietary live model: the favored side, a calibrated probability, its confidence and the key factors behind the call.

04

Match-winner prices

Bid, ask and mid per player with history — line the market up against the data and the model in a single call.

05

Players & history

Bios, rankings, ratings and season form; upcoming fixtures and completed results with the winner resolved.

06

Clean & documented

Predictable JSON, UTC timestamps, an OpenAPI 3.1 spec and drop-in REST + WebSocket clients. Built to integrate in an afternoon.

Products

More than the live feed

The live API is one of a family. Break-point Alerts and the Historical Data API run on the same key and the same schema, and you manage them all from one developer portal. See all products.

BPBreak-point Alerts

Real-time webhook and push alerts the instant a break point arises in any live match — wire them straight into a bot, a Discord or your phone, no polling.

Break-point Alerts
HHistorical Tennis Data API

The point-by-point tape over 179,578 completed matches back to January 2023, plus results and player stats for backtesting — the same clean JSON schema as the live feed, in one bulk-friendly API.

Historical Data API
DEVDeveloper Portal

Create an account, get an instant API key and manage your subscription — with the full REST + WebSocket reference a click away.

Sign up API docs
Historical data

Point by point, back to 2023

The point-by-point tape spans 45 monthly periods, January 2023 through September 2026 — across ATP, WTA, Challenger and ITF, singles and doubles. Each match declares how it was recorded, so you can filter to exactly the rows you trust. Below the tape’s floor sits the results archive (1968–2022): 1,485,752 ATP and WTA results with final score, seeds, ranks at the time and per-match serve statistics from 1991 — ending exactly where the tape begins, so no match is ever served from two datasets.

27,381,531Archived point-state rows
179,578Matches carrying a tape
45Monthly periods
96%Of completed matches

Counted September 14, 2026 over January 2023 → September 2026; the share is 179,578 of 187,832 completed matches on record.

Per-match coverage, declared on every response
ValueWhat it meansTimestamps
from_startWatched live from 0-0 — every row carries a real timestamp.real
partialPicked up mid-match — observed from that point onward.real
reconstructedPoint sequence taken from a point-by-point feed rather than our own observation.null
reconstructed_partialA reconstruction that does not cover the whole match — it opens after 0-0, or stops before the official final score.null
noneNo tape for this match.
?Filter to what you trust
?coverage=from_start
only matches watched live from 0-0

?sequence=clean
de-duplicated state sequence

Both compose with the tour and date-range filters, so a query returns only the rows you asked for.

{}Every response declares itself
"meta"
  "coverage" "from_start"
  "raw_rows" 1284
  "unique_states" 311
  "point_source" "observed"
  "model_rows" 287

point_source reads observed, reconstructed or mixed, so you always know exactly what you hold. model_rows counts how many of the rows returned carry a win-probability — the model stamp is best-effort, so filter on that number rather than assuming coverage implies it.

Monthly downloadable packages, with a sha256 manifest per file.

Historical Data API
The API

Predictable, and quick to wire up

Clean REST endpoints and a WebSocket stream, all under one base URL. Authenticate with a bearer token and you are live.

GET /matches?status=liveFree
GET /matches/{id}/scoreFree
GET /players/{id}Free
GET /history/matchesBasic
GET /history/matches/{id}Basic
GET /matches/{id}/statisticsUltra
GET /markets/{id}/pricesPro
GET /matches/{id}/analysisUltra
GET /rankings?as_of=Ultra
GET /rally/matches/{id}Ultra
WS /wsUltra
# Verify connectivity — no key needed
curl https://api.livetennisapi.com/api/public/v1/health

# List live matches
curl -H "Authorization: Bearer $API_KEY" \
  https://api.livetennisapi.com/api/public/v1/matches?status=live

Base URL — https://api.livetennisapi.com/api/public/v1

Buy it your way

Direct, or on the marketplace you use

Same data, same endpoints, same key format — wherever you subscribe.

LTDirect

Subscribe here, billed monthly via Stripe. Your key is issued instantly — best price, no marketplace markup.

View plans
RRapidAPI

The largest API hub — one key across your RapidAPI subscriptions, with a usage dashboard included.

View on RapidAPI
AApify

Run it as a pay-per-result Actor that streams scores and analysis straight into an Apify dataset.

View on Apify
MAPI.market

Subscribe through MagicAPI with unified billing and a single gateway key.

View on API.market
PPostman

Explore and test every endpoint in our public Postman workspace before you commit a line of code.

Explore in Postman
AIMCP server

Plug live tennis data straight into Claude, Cursor or any AI agent — 24 read-only tools, listed in the official MCP Registry.

Connect via MCP

Official client libraries

Install a typed client and be reading live scores in a minute — or point an LLM agent at the MCP server. All MIT licensed, all open source.

PYPython

Sync and async clients over every endpoint, a reconnecting WebSocket feed, and a livetennis CLI. Fully typed.

pip install livetennisapi

Package Source
TSJavaScript / TypeScript

Zero runtime dependencies — runs on Node, Deno, Bun, Workers and the browser. Ships types and a CLI you can run with npx.

npm install livetennisapi

Package Source
AIMCP server

Give Claude, Cursor or any MCP client 24 read-only tools over live tennis data. Listed in the official MCP Registry.

npx livetennisapi-mcp

Package Source

Full API reference at docs.livetennisapi.com · OpenAPI specification on GitHub.

Built on Live Tennis API

Independent tutorials and tools from developers using the API. Written by them, not us — including where they found the limits.

BOTEvent-driven trading bots

BotBlog on wiring live score commits straight into bot logic over the WebSocket — reacting the moment a point lands instead of polling for it, with a measured latency study.

Read it
PYBeginner live scores dashboard

A step-by-step Python and Flask build for a personal live scoreboard. Written for absolute beginners — no prior API experience assumed.

Read it
WEBTennis Trader Board

A free hosted board built on the API, so you can watch live scores update before deciding whether you want a key at all.

Read it

Built something? Tell us at hello@livetennisapi.com and we will link it here.

FAQ

Answers before you build

How much does the Live Tennis API cost?

Four plans, billed monthly in USD. Free — $0: live and upcoming matches, scores, players, fixtures and tournaments at 30 requests a minute and 100 a day, instant key, no card. Basic — $9.99: adds completed results, the point-by-point record, the 1968–2022 results archive and head-to-head. Pro — $29.99: adds match events, market prices and ranking tables. Ultra — $99.99: adds AI win-probability, in-play statistics, rally construction and the streaming push feed. Subscribe directly here for an instant key, or on RapidAPI, Apify and API.market.

Can I upgrade my plan mid-cycle?

Yes — upgrade here. Upgrades apply immediately on your existing subscription and API key; Stripe bills only the prorated difference for the rest of the cycle. You never pay for two plans at once, and your key never changes. Your base URL stays the same too; only the tier's endpoints and limits change. Downgrades and cancellations are self-serve from the customer portal, with no call to book and no quote to wait for.

What data do I get on each plan?

Free: live scores & current matches, players, fixtures and your usage — 30 requests/min, 100/day; no history, odds, model fields or WebSocket. Basic ($9.99) adds historical match results, the point-by-point match tape (GET /history/matches/{id}), the results archive back to 1968, head-to-head (GET /h2h) and career aggregates — 60/min, 1,000/day. Pro ($29.99) adds match events, match-winner market odds and bulk monthly history packages — 300/min, 10,000/day. Ultra ($99.99) adds the AI win-probability model fields and analysis, per-match live statistics (aces, double faults, serve split, break points saved and converted), shot-level match-charting stats (serve placement, return depth, net & serve-and-volley, clutch break/game/set-point serving), head-to-head stat splits, the WebSocket live feed and webhooks — 600/min, 500,000/day.

How far back does the historical data go?

Two layers, two depths. Results go back to 1968: the results archive holds 1,485,752 ATP and WTA results from 1968 through 2022 — final score, seeds, each player's rank at the time, round and draw metadata, and per-match serve statistics from 1991 — with yearly bulk packages. The point-by-point tape then takes over exactly where the archive ends: 45 monthly periods, January 2023 through September 2026, across ATP, WTA, Challenger and ITF — singles and doubles, 27,381,531 archived point-state rows over 179,578 of 187,832 completed matches, growing as the backfill runs. Bulk packages are published per calendar month (tape) and per year (archive), each with a sha256 manifest per file.

Do you have shot-by-shot rally data?

Yes, on ULTRA, and it is a different product from the tape. The tape gives the ordered score states of the match; rally construction gives how the point was played — serve direction, every stroke with its wing, direction and depth, the rally length and how the point ended. 11,638 charted matches (7,565 men’s back to 1960, 4,073 women’s), 1,850,490 points. Read one match at GET /rally/matches/{id} or take the whole thing as bulk yearly files. Charting is human work, so coverage is deep rather than universal and is concentrated on the biggest events — GET /rally/matches is the authoritative list of what exists.

Do you have deep serve and return statistics — aces, break points, serve placement?

Yes, on ULTRA, at three depths. Per live/completed match, GET /matches/{id}/statistics gives aces, double faults, the first/second-serve split, and break points saved and converted — and a completed match keeps its final figures, not just while it is live. Across a pairing, GET /h2h adds serve/return/break-point aggregates. And the deepest layer, GET /charting/players, gives shot-level career stats from the Match Charting Project — serve placement (deuce/ad × wide/body/T), return depth and outcomes, net and serve-and-volley conversion, and clutch break/game/set-point serving and returning — over 11,638 charted matches back to 1960. Coverage there is curated, majors-heavy, and every response reports its matches_charted sample.

What is in the point-by-point tape?

The ordered score states of a completed match, with match metadata. Each match declares its own coverage, and the differences are real rather than cosmetic: from_start means we watched it live from 0-0 — every row carries a real timestamp, and our model's win-probability where it was computed (that stamp is best-effort, so where it was not, the field is null rather than guessed); partial means we picked it up mid-match; reconstructed means the point sequence came from a point-by-point feed rather than our own live observation, so those rows carry a null timestamp and no model fields. Nothing is ever synthesised from a final scoreline. The meta block on every response repeats that alongside raw_rows, unique_states and point_source, so you always know exactly what you are holding. Completeness is measured per match, not assumed: meta.points carries a measured verdict on every tape read, ?points=complete serves the sequence in full — score after each point, with server and point winner — where that verdict is complete, and ?points_complete=true filters the match list to measured-complete tapes. As of September 14, 2026, 70.1% of completed matches since 2023 are measured point-complete, and running backfills keep raising that share. Per-match tape reads come with Basic and above; bulk monthly packages come with Pro and above, or with a Historical Data API package purchase. There is no odds tape in the history product.

Which tours and formats are covered?

ATP, WTA, Challenger and ITF — both singles and doubles — from one arbitrated feed, and every match declares how it was recorded so you can filter to the rows you trust. Live in-play statistics (aces, double faults, points and break points) cover every tour including ITF; the serve split covers ATP, WTA and Challenger. Tennis only: not table tennis, padel or pickleball.

Is there a WebSocket / live stream?

Yes. The Ultra plan pushes each score update as it is scored, so you never have to poll. Continuous streaming runs on the push feed (GET /ws-token), built to fan out to thousands of subscribers; a native WebSocket remains available for quick console tests. Both carry per-point event frames on covered matches, with GET /matches/{id}/points for catch-up; each match declares its own pbp_coverage (point where a point vendor covers it, game otherwise), so you always know which cadence you are subscribed to.

How fresh are the live scores?

Scores come from an arbitrated multi-source feed. Rather than quote a number you cannot check, every push frame carries published_at next to the event timestamp: published_at - timestamp is our processing time, and your receive time minus published_at is transport. Measure it on your own connection.

How do I authenticate?

Send your API key on every request to https://api.livetennisapi.com/api/public/v1 as an Authorization: Bearer <key> header, or as X-API-Key. Keys look like twjp_… and are issued instantly when you subscribe — the free key needs no card. A missing or wrong key returns 401; a call to an endpoint above your plan returns an upgrade_required error that names the plan which unlocks it, so a client can tell the two apart.

What is the AI win-probability?

A proprietary model's live win-probability for each player — a probability between 0 and 1, recalculated as points are played — with a confidence level, the model's thesis and the key factors behind the call. It is available on the Ultra plan. Match rows carry has_analysis, so a client can check whether a match has a thesis before requesting it; a match without one returns nothing rather than a guess.

Can I try it before paying?

Yes. The free tier is the trial, and it never expires: live and upcoming matches, scores, players, fixtures and tournaments at 30 requests a minute and 100 a day, with an instant key and no card. The full API reference is readable without a key, the /health endpoint needs no key at all, and every endpoint can be explored in our public Postman workspace. Upgrade only when your own workload tells you the data is worth it.

Start building on live tennis

Pick a plan, get an instant API key, and make your first call in minutes.