What is a tennis odds API?

It is an HTTP endpoint that returns tennis market prices as structured data instead of a betting page. Live Tennis API's version, GET /markets/{id}/prices, returns match-winner market prices — implied probability, bid, ask and mid for each player — as JSON you can feed into models or dashboards. It requires the Pro plan and the X-API-Key header.

What does the market-prices endpoint return?

For a given match id, it returns match-winner market prices per player: an implied probability (0-1), a bid and ask (the two sides of the quoted price) and a mid (the midpoint most models use). The market id is the match id, so you can join prices to the same match's scores and point-by-point data.

Which plan do I need for tennis odds data?

Market prices are on the Pro plan ($29.99/mo, 300 requests/min, 10,000/day). Live scores, fixtures and player data below it are on the free tier; completed-match history and the point-by-point tape are on Basic ($9.99/mo). A 403 response means your key's plan is below Pro.

How do I get a match id to request prices for?

Call the free GET /matches?status=live endpoint (or GET /fixtures for upcoming matches) and read the id field from each match. Pass that id to /markets/{id}/prices. Both calls use the same base URL, https://api.livetennisapi.com/api/public/v1, and the same X-API-Key header.

Does this API give betting tips or predictions?

No. The market-prices endpoint is a data feed only — it returns numbers, not recommendations. If you want model-based win probabilities, the Ultra plan adds a separate /matches/{id}/analysis endpoint, but that is analysis output, still not betting advice.

Tennis Odds & Market-Prices API for Developers

Pull tennis match-winner market prices (odds data) as JSON: implied probability, bid, ask and mid per player. Real endpoints, curl + Python, Pro tier.

Live Tennis API exposes tennis odds as a structured data product: call GET /markets/{id}/prices with your X-API-Key and you get match-winner market prices for a match — an implied probability, bid, ask and mid for each player, as clean JSON. It is available on the Pro plan and is meant for building models, dashboards and research, not betting advice.

This is a developer reference for that endpoint. Odds here means one thing only: a machine-readable price feed you can join against scores, players and point-by-point data from the same API.

What the tennis odds endpoint returns

The market-prices surface answers a narrow question: for a given match, what does the market-winner market currently price each player at? Each price point carries:

implied probability — the price expressed as a 0-1 probability
bid / ask — the two sides of the quoted market price
mid — the midpoint, the value most models use

Prices are keyed to a match — pass the match's id (from the live-matches or /fixtures feed) to the markets endpoint — so you can line them up with the same match's score, players and, on Basic and above, its point-by-point tape.

Base URL for every call: https://api.livetennisapi.com/api/public/v1. Auth is a single header, X-API-Key: <your key>.

Quickstart: fetch market prices with curl

First find a match id from the free live-matches endpoint, then request its prices:

# 1. What's on right now (free tier)
curl -s "https://api.livetennisapi.com/api/public/v1/matches?status=live" \
  -H "X-API-Key: $LIVE_TENNIS_API_KEY"

# 2. Match-winner market prices for one match (Pro tier)
curl -s "https://api.livetennisapi.com/api/public/v1/markets/12345/prices" \
  -H "X-API-Key: $LIVE_TENNIS_API_KEY"

Replace 12345 with an id from the live-matches (or /fixtures) response.

Python: implied probabilities for a live match

The official SDK (pip install livetennisapi) wraps the same endpoints, but here is a dependency-light version using requests so the wire format is visible:

import os
import requests

BASE = "https://api.livetennisapi.com/api/public/v1"
HEADERS = {"X-API-Key": os.environ["LIVE_TENNIS_API_KEY"]}

def live_match_ids(limit=5):
    r = requests.get(f"{BASE}/matches", params={"status": "live"}, headers=HEADERS)
    r.raise_for_status()
    return [m["id"] for m in r.json()["matches"][:limit]]

def market_prices(match_id):
    r = requests.get(f"{BASE}/markets/{match_id}/prices", headers=HEADERS)
    r.raise_for_status()
    return r.json()

for mid in live_match_ids():
    prices = market_prices(mid)
    for p in prices.get("prices", []):
        print(mid, p["player"], "mid", p["mid"], "implied", p["implied_probability"])

The mid field is usually what you feed a model; bid/ask let you see the spread. A 401 means the key is missing or wrong; a 403 means your plan is below Pro for this endpoint.

JavaScript: same call in Node

// npm i livetennisapi  — or use fetch directly, shown here
const BASE = "https://api.livetennisapi.com/api/public/v1";
const headers = { "X-API-Key": process.env.LIVE_TENNIS_API_KEY };

async function marketPrices(matchId) {
  const res = await fetch(`${BASE}/markets/${matchId}/prices`, { headers });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

marketPrices(12345).then((data) => {
  for (const p of data.prices) {
    console.log(p.player, "mid", p.mid, "implied", p.implied_probability);
  }
});

Which tier do I need?

Market prices live on Pro ($29.99/mo, 300 req/min, 10,000 req/day), alongside the rank-ordered rankings listing. The tiers below still matter because a prices feed is only useful next to context:

Free (30/min, 100/day): live matches, current scores, player profiles with ranking and Elo, fixtures — the state of play, no card required. Get a key at https://livetennisapi.com/subscribe/free .
Basic ($9.99/mo): adds completed-match history and the point-by-point tape.
Pro ($29.99/mo): adds /markets/{id}/prices and the rankings listing.
Ultra ($99.99/mo): adds win-probability analysis, live per-point events and the WebSocket stream (WS /ws).

A common pattern: pull prices on Pro, join them to the free scores feed and — for research on how prices moved through a match — to the Basic point-by-point tape. See the point-by-point data guide for that surface, and the pillar tennis API guide for the full endpoint map.

Notes and tooling

Full schemas: https://docs.livetennisapi.com and the OpenAPI spec at github.com/livetennisapi/openapi .
An MCP server (mcp.livetennisapi.com) exposes the same market-prices tool to AI agents.
Coverage is ATP, WTA, Challenger and ITF.

This endpoint is a price data feed. It carries no recommendations, and nothing here is betting guidance — use the numbers as an input to whatever you are modelling.