Polymarket tennis trading toolkit (Python, MIT, observe-only): discover tennis markets on the Gamma API, match them to live tennis matches, watch market price vs live score, server and break point. The data layer for a Polymarket or Kalshi tennis trading bot.
# Add to your Claude Code skills
git clone https://github.com/livetennisapi/polymarket-tennisGuides for using data processing skills like polymarket-tennis.
polymarket-tennis is an open-source data processing skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by livetennisapi. Polymarket tennis trading toolkit (Python, MIT, observe-only): discover tennis markets on the Gamma API, match them to live tennis matches, watch market price vs live score, server and break point. The data layer for a Polymarket or Kalshi tennis trading bot. It has 56 GitHub stars.
polymarket-tennis's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/livetennisapi/polymarket-tennis" and add it to your Claude Code skills directory (see the Installation section above).
polymarket-tennis is primarily written in Python. It is open-source under livetennisapi on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other Data Processing skills you can browse and compare side by side. Open the Data Processing category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh polymarket-tennis against similar tools.
No comments yet. Be the first to share your thoughts!
Top skills in this category by stars
Unlocks once the catalog security scan passes (runs nightly).
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM is an informational directory and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
The live-data layer for Polymarket tennis trading: discover tennis event markets, match them to live tennis scores, and watch market prices against the real match state — score line, server, break-point flag — in one joined view.
Disclosure: this toolkit is built and maintained by the team behind the Live Tennis API. It joins Polymarket's public market data with our live-score feed, so this is vendor-authored tooling — judge accordingly.
Observe-only by design. This package reads public market data and live scores. It contains no order execution, no wallet or key handling, and no strategy advice; execution is out of scope, permanently.
Cincinnati Open: Jiri Lehecka vs Arthur Fils [atp-lehecka-fils-2026-08-17]
market: Jiri Lehecka 0.095 | Arthur Fils 0.905 (as of 12s ago)
live: Jiri Lehecka vs Arthur Fils 4-6 3-4 (15-40) serving: Jiri Lehecka [BREAK POINT] (as of 8s ago)
The discovery module finds current tennis markets via Polymarket's
public Gamma API (keyless): the tennis
tag, per-match events (atp-lehecka-fils-2026-08-17), futures, doubles;
normalized to plain Python objects (question, outcomes, prices, volume,
end date).
Tennis is a large, active category on Polymarket: on 2026-08-18 we counted 400+ open singles moneyline markets on the Gamma API across ATP, WTA, Challenger and ITF events, plus set-winner, games over/under and futures markets alongside them.
pmtennis discover --matches-only --moneyline-only
The matching module pairs a market with a Live Tennis API
match/fixture using player-name + date heuristics with an explicit
confidence score. Handles reversed name order ("Alcaraz vs Sinner" /
"Sinner vs Alcaraz"), diacritics ("Báez" = "Baez"), shared surnames, and
retirement/walkover wording. On ambiguity it returns None — it never
guesses silently. An explicit match-id override is always available.
Matching semantics, precisely:
None. One player agreeing → None. A date
disagreeing by more than a day → None.--match-id/override_match_id explicitly if you need one.False whenever server or points are null
(completed matches carry null points).The join module builds a LiveMarketView: one snapshot holding the
market question and outcome prices next to the live score line, server,
break-point flag, and set/game state, with staleness timestamps for
both feeds.
pip install polymarket-tennis
# or from source:
pip install "polymarket-tennis @ git+https://github.com/livetennisapi/polymarket-tennis"
Python 3.10+. Single runtime dependency: httpx.
# 1. list current tennis markets — keyless, Gamma only
pmtennis discover --matches-only --moneyline-only
# 2. get a free Live Tennis API key (https://livetennisapi.com/subscribe/free)
export LIVETENNIS_API_KEY=ltapi_...
# 3. inspect the matching decision for one market
pmtennis match atp-lehecka-fils-2026-08-17
# 4. watch market price vs live match state, one poll per minute
pmtennis watch atp-lehecka-fils-2026-08-17
As a library:
from polymarket_tennis import (
GammaClient, LiveTennisClient,
discover_tennis_markets, match_market, build_view,
)
with GammaClient() as gamma, LiveTennisClient() as lta:
markets = discover_tennis_markets(gamma, market_types={"moneyline"},
matches_only=True)
candidates = lta.live_matches() + lta.fixtures()
for market in markets:
decision = match_market(market, candidates)
if decision is None:
continue # ambiguous or no live counterpart — never guessed
view = build_view(market, decision.match)
print(view.render())
To be clear about the boundary: this toolkit is the data layer, not a
bot. It never places orders and never will. What it gives a Polymarket
tennis trading bot is the part that is genuinely fiddly — reliable market
discovery, market↔match identity resolution that refuses to guess, and a
joined market-price/live-score snapshot with staleness timestamps — so your
own code can focus on whatever decisions it makes. Everything downstream of
the LiveMarketView (signals, execution, risk) is yours to build, with
Polymarket's own official interfaces, and none of it lives here.
The Live Tennis API free tier allows 30 requests/minute and 100 requests/day and includes live scores (score/server/state), players (with each player's own current ranking), fixtures, and usage.
pmtennis watch spends 1 Live Tennis API request per poll (the market
price comes from Gamma, which is keyless and doesn't touch your quota):
| cadence | requests/hour | free-key watching per day |
|---|---|---|
| 60 s (default) | 60 | ~100 minutes |
| 300 s | 12 | ~8 hours |
So the free tier comfortably covers developing, testing, and following a handful of tracked matches at a gentle cadence — it is not sized for continuous fast polling of many matches. Paid tiers add completed-match history and point-by-point (Basic), match events, market prices and bulk packages (Pro), and win probability and in-play stats (Ultra) — details at livetennisapi.com.
Note on price data: all market prices in this toolkit come from Polymarket's public Gamma API. The Live Tennis API's own market-prices and win-probability fields are paid-tier features and are not required by anything here.
No experience needed. Get a free key, open Claude Code in an empty folder, and paste this one prompt. It builds an observe-only, paper-trading watcher on top of this toolkit — it cannot place orders, because nothing in this package can.
Build me a Python tennis market watcher on top of the `polymarket-tennis`
package (pip install polymarket-tennis; docs: https://github.com/livetennisapi/polymarket-tennis).
Requirements:
1. Use GammaClient + discover_tennis_markets(market_types={"moneyline"}, matches_only=True)
to list open Polymarket tennis markets, and LiveTennisClient (key from the env var
LIVETENNIS_API_KEY; free key at https://livetennisapi.com/subscribe/free) to fetch
lta.live_matches() + lta.fixtures().
2. For each market call match_market(market, candidates); skip None (never guess).
3. Build view = build_view(market, decision.match) and, once per minute (free tier:
30 req/min, 100 req/day — stay under it), log: market question, both outcome prices,
the live score line, who is serving, the break-point flag, and both staleness ages.
4. Keep a local JSON "paper book": when the favourite is facing a break point, record a
PAPER entry {time, market, side, price}; when the game resolves, record the price
move. Paper only — print a loud banner that no real orders are ever sent.
5. If the match's `outcome` becomes "retired" or "walkover" print the venue's own
settlement text from the market `description` (do NOT hard-code a payout rule).
6. Add a README, a requirements.txt, and tests that run offline with fixtures.
Observe-only. No wallets, no keys other than the tennis API key, no order code.
What that prompt produced, unedited except for lint, is checked in at
examples/claude-code-watcher/ — 7 offline
tests, ruff clean, and a --once --fixtures dry run so you can see it work
without a key. Its README lists the honest deviations (e.g. the prompt's
"once a minute" costs 2 requests per poll, which exceeds 100/day, so the
watcher self-caps at 96 requests and documents --interval 300). The
write-up is in Build a Polymarket tennis trading bot (Python).
A strategy leaderboard built on the toolkit: write a Python file with an
on_view(view, book) method, replay it over a recorded tape of market +
live-score snapshots, and get ranked by paper P&L. No orders, no
wallets; entrants never receive raw venue prices, only scores. Season 1 is
the US Open 2026. Rules, data-handling constraints and the CLI
(pmtennis arena replay|record) are in docs/ARENA.md.
The only committed tape is clearly synthetic.
An Agent Skill for this package lives at
skills/polymarket-tennis/: the real API surface,
the free-tier budget, the outcome/event_status detection rule, the one-prompt
build, and the verbatim retirement/walkover settlement matrix — with the same
observe-only guardrails as this README. Install it into a project with
npx skills add livetennisapi/polymarket-tennis
# or copy skills/polymarket-tennis/ into .claude/skills/
It is also bundled in the livetennisapi-mcp Claude Code plugin.