Agent skill

Polymarket Tennis

by livetennisapi in livetennisapi/livetennisapi-mcp

Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier.

MITAuto-check passedBusiness, Finance & HR

Install Polymarket Tennis

skills CLI
$ npx skills add livetennisapi/livetennisapi-mcp --skill polymarket-tennis -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install livetennisapi/livetennisapi-mcp polymarket-tennis --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/livetennisapi/livetennisapi-mcp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/polymarket-tennis .claude/skills/polymarket-tennis && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
polymarket-tennis
GitHub stars
152
Token cost
~3k tokens
SKILL.md length
1,085 words
Files
4 (incl. references)
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier.

  • Works in 6 steps: Observe-only. Never add order placement,… → Never hard-code a settlement rule.… → Respect the free tier: 30… → …
  • Asked for a Polymarket tennis bot
  • SKILL.md covers Hard guardrails (apply to…, Quick start, The package, in one screen and Workflow: build a watcher or…, plus 5 more sections
  • Calls pip and ruff; reaches livetennisapi.com; needs LIVETENNIS_API_KEY and LIVETENNISAPI_KEY

What it does

Polymarket Tennis is an agent skill from livetennisapi/livetennisapi-mcp. Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier. Use when asked for a Polymarket tennis bot or market watcher, a Kalshi tennis trading bot, tennis prediction-market data, Gamma API tennis markets, matching a market to a live match, break-point or serving state next to market prices, or how a tennis retirement, walkover, or cancelled match settles (venue rule text, never hard-coded). Covers the real package API…

Its SKILL.md is about 3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/api.md`, `references/one-prompt-build.md` and `references/settlement-rules.md`). Compatibility notes: Python 3.10+, pip install polymarket-tennis (single runtime dependency httpx). Live match data needs a free Live Tennis API key in LIVETENNISAPIKEY…

It sits in Business, Finance & HR, covering Trading and backtesting, Stock and market analysis and MCP servers. It works with Polymarket, Kalshi, Model Context Protocol and Python. The repository describes itself as: MCP server for the Live Tennis API — give Claude, Cursor and other LLM agents real-time tennis scores, odds and model win-probability. The licence is MIT.

When your agent uses it

  • Asked for a Polymarket tennis bot
  • A Kalshi tennis trading bot
  • Tennis prediction-market data
  • Gamma API tennis markets

Example prompts

  • “/polymarket-tennis”

Requirements

  • Python 3
  • A credential in LIVETENNIS_API_KEY
  • A credential in LIVETENNISAPI_KEY
  • Compatibility (from SKILL.md): Python 3.10+, pip install polymarket-tennis (single runtime dependency httpx). Live match data needs a free Live Tennis API key in LIVETENNIS_API_KEY; Polymarket Gamma and Kalshi market reads are keyless.

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Observe-only. Never add order placement, wallet, private-key, or CLOB code to
  2. Never hard-code a settlement rule. Retirement and walkover payouts differ by
  3. Respect the free tier: 30 requests/minute, 100 requests/day. Every
  4. Detect match endings with outcome and event_status, not status.
  5. Never guess a market-to-match pairing. match_market returns None on
  6. Tests stay offline. Use trimmed fixtures and httpx.MockTransport; never

What it can do on your machine

Read from SKILL.md and the folder at commit b52784f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • pip
    • ruff

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • livetennisapi.com

    Also links to:

    • blog.livetennisapi.com
    • github.com
    • docs.livetennisapi.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • LIVETENNIS_API_KEY
    • LIVETENNISAPI_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Python 3.10+, pip install polymarket-tennis (single runtime dependency httpx). Live match data needs a free Live Tennis API key in LIVETENNIS_API_KEY; Polymarket Gamma and Kalshi market reads are keyless.

    From compatibility in the SKILL.md frontmatter.

Context cost

Polymarket Tennis loads about 3k tokens when it runs, and up to ~8.8k if it reads all its reference files. Until then it costs about 200 tokens; SKILL.md has 1,085 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~200
When it runs · the whole SKILL.md, loaded when a task matches
~3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~8.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from livetennisapi/livetennisapi-mcp at commit b52784f, republished under its MIT licence (© livetennisapi). 1,085 words, ~3,032 tokens.

Download SKILL.mdSave it as .claude/skills/polymarket-tennis/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
polymarket-tennis
description
Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier. Use when asked for a Polymarket tennis bot or market watcher, a Kalshi tennis trading bot, tennis prediction-market data, Gamma API tennis markets, matching a market to a live match, break-point or serving state next to market prices, or how a tennis retirement, walkover, or cancelled match settles (venue rule text, never hard-coded). Covers the real package API (GammaClient, LiveTennisClient, discover_tennis_markets, match_market, build_view, pmtennis CLI), the free-tier request budget (30/min, 100/day), the outcome and event_status fields, and the verbatim 2026 settlement matrix. No order execution, wallets, or strategy advice.
compatibility
Python 3.10+, pip install polymarket-tennis (single runtime dependency httpx). Live match data needs a free Live Tennis API key in LIVETENNIS_API_KEY; Polymarket Gamma and Kalshi market reads are keyless.
license
MIT
metadata.author
Live Tennis API (hello@livetennisapi.com)
metadata.version
0.1.0
metadata.homepage
https://github.com/livetennisapi/polymarket-tennis
metadata.attribution
Vendor-authored. The live-score side of every join comes from the Live Tennis API; judge accordingly.

Polymarket / Kalshi tennis trading data

Vendor-authored, observe-only. This skill is maintained by the team behind the Live Tennis API. It teaches the polymarket-tennis package, which reads public market data and live scores. It contains no order execution, no wallet or private-key handling, no CLOB client, and no strategy advice. Execution is permanently out of scope. Nothing here is financial advice.

Hard guardrails (apply to every file you write with this skill)

  1. Observe-only. Never add order placement, wallet, private-key, or CLOB code to anything built on this package. If the user wants execution, it belongs in their own code behind a clearly separated seam, using the venue's own official interfaces, and this skill does not write it.
  2. Never hard-code a settlement rule. Retirement and walkover payouts differ by venue (polymarket.com vs Polymarket US vs Kalshi) and by tour (ATP/WTA vs ITF). Read the market's own text — Gamma description (market.raw["description"]), Kalshi rules_secondary — and print it. The reference matrix in references/settlement-rules.md is for the human, not for code branches.
  3. Respect the free tier: 30 requests/minute, 100 requests/day. Every LiveTennisClient call costs one request; Gamma and Kalshi reads cost nothing. pmtennis watch is 1 request per poll at a 60 s default (minimum 30 s). A watcher that calls live_matches() + fixtures() per poll costs 2 per poll and must self-cap (the reference build caps at 96/day, --interval 300).
  4. Detect match endings with outcome and event_status, not status. status is only the lifecycle (upcoming|live|completed|cancelled). outcome is completed|retired|walkover|default|abandoned and null until settled; event_status is the feed designator (Retired, Walk Over, Cancelled, Postponed, Interrupted); withdrew names who stopped.
  5. Never guess a market-to-match pairing. match_market returns None on ambiguity; skip it. Use override_match_id / --match-id only when the user supplies the id explicitly.
  6. Tests stay offline. Use trimmed fixtures and httpx.MockTransport; never put live calls in tests.

Quick start

bash
pip install polymarket-tennis          # Python 3.10+, depends only on httpx
pmtennis discover --matches-only --moneyline-only   # keyless, Gamma only
export LIVETENNIS_API_KEY=ltapi_...    # free, no card: https://livetennisapi.com/subscribe/free
pmtennis match atp-lehecka-fils-2026-08-17          # show the pairing decision + confidence
pmtennis watch atp-lehecka-fils-2026-08-17          # 1 request per poll, 60 s default

Env-var names differ between the two Live Tennis API tools: the Python package reads LIVETENNIS_API_KEY; the livetennisapi-mcp server/plugin reads LIVETENNISAPI_KEY. Same key value works in both.

Library form — every symbol below is exported from polymarket_tennis.__init__:

python
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()   # 2 free-tier requests
    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())

Sample view.render() output:

text
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 package, in one screen

SymbolWhat it doesNetwork cost
GammaClient()Polymarket Gamma API (keyless): events(), event_by_slug(), market_by_id(), market_by_slug(), market()none against your key
LiveTennisClient(api_key=None)Live Tennis API; key from LIVETENNIS_API_KEY: matches(), live_matches(), match(id), fixtures(), players(search)1 request per call
discover_tennis_markets(client, market_types=None, include_closed=False, matches_only=False, limit=100)normalized TennisMarket list from the tennis tagGamma only
find_market(client, id_or_slug)one TennisMarket by Gamma id, market slug, or event slugGamma only
match_market(market, candidates, override_match_id=None, threshold=0.70, ambiguity_margin=0.10)MatchDecision or Nonepure
build_view(market, match)LiveMarketView with both feeds' stalenesspure
derive_break_point(score), score_line(score)helpers used by the viewpure
TennisMarket.price_by_outcome, .slug_date, .rawprices dict, slug date, the raw Gamma object (settlement text lives in raw["description"])—

Full signatures, dataclass fields, and the live-match JSON shape are in references/api.md. Read it before writing code that touches fields not shown above — in particular, TennisMarket has no description attribute and LiveMarketView does not expose outcome; go through .raw and .match.

Workflow: build a watcher or bot data layer

  1. Discover with discover_tennis_markets(gamma, market_types={"moneyline"}, matches_only=True). Futures/outrights are dropped by matches_only; doubles markets are rejected by the matcher in v0.1.
  2. Fetch candidates once per poll: lta.live_matches() (+ lta.fixtures() if you need pre-start matches). Count the requests; budget them against 100/day.
  3. Pair each market with match_market(market, candidates); skip None. Log decision.confidence and decision.method ("explicit" | "names+date" | "names").
  4. Join with build_view(market, decision.match); read view.prices, view.score_line, view.server (1/2), view.break_point, view.is_tiebreak, view.event_status, and both view.market_staleness() / view.live_staleness().
  5. Settlement branch: read view.match.get("outcome") and view.match.get("event_status"); when outcome in ("retired", "walkover", "default", "abandoned") or event_status == "Cancelled", print view.market.raw.get("description") verbatim (fall back to rules_secondary, then say the payload carries no rule text). Do not compute a payout.
  6. Paper only: any "signal" the user asks for is logged to a local JSON book with a loud banner that no orders are sent. See the verified reference build.
python
def settlement_text(view) -> str:
    raw = view.market.raw
    text = raw.get("description") or raw.get("rules_secondary")
    return text or "(market payload carries no settlement text; read it on the venue)"
Show full SKILL.md (442 more words)Show less

Kalshi

The package discovers Polymarket markets (Gamma). Kalshi publishes each market's rule text in its public read endpoint, keyless; the same outcome/event_status detection applies. Use the package's LiveTennisClient for the live side and read Kalshi directly for the market side (see references/settlement-rules.md for the Kalshi snippet and the ATP/WTA vs ITF series difference). Do not hard-code the ITF $0.50 rule; print rules_secondary.

One-prompt build (verified output checked in)

When the user wants a watcher "vibe-coded" end to end, use the prompt in references/one-prompt-build.md. It is the exact prompt from the package README; what it produced, unedited except for lint, is in examples/claude-code-watcher/ of the repository (7 offline tests, ruff clean, --once --fixtures dry run without a key). That README also lists the honest deviations — read them before re-running the prompt, because two of them are traps: the prompt's "once a minute" costs 2 requests per poll (so the watcher must self-cap), and the offline fixtures carry event_status but no outcome key.

Retirement / walkover rule matrix (retrieved 2026-08-23)

The short version, for the human reading this — the code must still print the market's own text:

ScenarioPolymarket (polymarket.com)Polymarket USKalshi (ATP/WTA)Kalshi (ITF)
Walkover / withdrawal before the match starts50-50Last fair market price at announcementFair price per rules$0.50 per contract
Match cancelled, not played50-50Last fair market priceFair price per rules$0.50
Retirement after play starts (injury, default, DQ)Advancing player winsAwarded winner settles $1.00Winner resolves Yes ("after a ball has been played")Winner Yes; withdrawing/forfeiting player No
Delayed / postponed50-50 if beyond 7 days with no winner— (see venue FAQ)Stays open, closes after rescheduled match (within two weeks)Same as ATP/WTA
What counts as "started""the match begins"First serve is struckA ball has been playedA ball has been played

Verbatim venue quotes, source URLs, retrieval dates, and the live-data mapping (outcome/event_status/withdrew to each venue column) are in references/settlement-rules.md. Rules are per market and can change; the market's own text always wins over that file.

Verification checklist before you hand code back

  • ruff check clean; tests run with no network (httpx.MockTransport or fixture files).
  • Every import resolves to a symbol listed in references/api.md.
  • Request count per poll is computed and documented against 30/min, 100/day.
  • No payout number appears in code; the venue text is printed instead.
  • Match-end detection reads outcome / event_status, never status == "completed" alone.
  • A banner states that no orders are ever sent.

Further reading

© livetennisapi, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in skills/polymarket-tennis of livetennisapi/livetennisapi-mcp.

  • SKILL.md
  • references/api.md
  • references/one-prompt-build.md
  • references/settlement-rules.md

Open the folder on GitHubat commit b52784f

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders. This page covers the copy in livetennisapi/livetennisapi-mcp, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Polymarket Tennis next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Polymarket Tennis compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Polymarket Tennis this skilllivetennisapi/livetennisapi-mcp152—~3kAutomated safety check: PassMIT
Okx Sentiment Trackerdex-original/okx-agent-trade-kit1101 repos~3.8kAutomated safety check: PassMIT
Tiger Brokers OpenAPI SDKqusong0627/QuantMind1.7k—~1.4kAutomated safety check: PassApache-2.0
Web3 PolymarketPolymarket/agent-skills1921 repos~2kAutomated safety check: PassNone
Dr Manhattanguzus/dr-manhattan204—~2kAutomated safety check: PassApache-2.0
Tradingview MCPatilaahmettaner/tradingview-mcp5k—~1.3kAutomated safety check: PassMIT

Similar skills

  • Okx Sentiment Tracker

    dex-original/okx-agent-trade-kit

    A skill your agent uses when the user asks about: 'any crypto news', 'latest news', 'market update', 'daily briefing', 'BTC news', 'ETH news', 'news on SOL', 'search SEC ETF', 'regulation news'…

    110 GitHub starsUsed in 1 repo~3.8k tokens
    Business, Finance & HRAuto-check passed
  • Tiger Brokers OpenAPI SDK

    qusong0627/QuantMind

    Covers the Tiger Brokers OpenAPI Python SDK for market data, stock, futures and options trading, push subscriptions, a CLI and an MCP server, defaulting to paper trading.

    1.7k GitHub stars~1.4k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Web3 Polymarket

    Polymarket/agent-skills

    Polymarket integration for prediction market trading on Polygon.

    192 GitHub starsUsed in 1 repo~2k tokens
    Backend & APIsAuto-check passed
  • Dr Manhattan

    guzus/dr-manhattan

    Trade prediction markets (Polymarket, Kalshi, Opinion, Limitless, Predict.fun) using a unified CCXT-style API.

    204 GitHub stars~2k tokensUpdated 2 mo ago
    Business, Finance & HRAuto-check passed
  • Tradingview MCP

    atilaahmettaner/tradingview-mcp

    AI Trading Intelligence — live prices, 30+ technical indicators, backtesting (6 strategies), walk-forward overfitting detection, trade logs, equity curves, licensed news sentiment (Marketaux), and…

    5k GitHub stars~1.3k tokensUpdated yesterday
    Business, Finance & HRAuto-check passed
  • Digital Oracle

    komako-workshop/digital-oracle

    Answer prediction questions using market trading data, not opinions.

    878 GitHub stars~5.9k tokensUpdated 2 mo ago
    Business, Finance & HRAuto-check passed

Questions about Polymarket Tennis

What does Polymarket Tennis do?

Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier. Polymarket Tennis is an agent skill from livetennisapi/livetennisapi-mcp. Build observe-only Polymarket and Kalshi tennis market tooling on the polymarket-tennis Python package (MIT) plus the Live Tennis API free tier.

When should I use Polymarket Tennis?

Polymarket Tennis fits situations like: asked for a Polymarket tennis bot; A Kalshi tennis trading bot; tennis prediction-market data; gamma API tennis markets.

How do I install Polymarket Tennis in Claude Code?

Run `npx skills add livetennisapi/livetennisapi-mcp --skill polymarket-tennis -a claude-code`. Or copy the skill folder (skills/polymarket-tennis in livetennisapi/livetennisapi-mcp) into .claude/skills/polymarket-tennis in your project. Claude Code loads it when a task matches its description.

How do I install Polymarket Tennis in Codex?

Run `npx skills add livetennisapi/livetennisapi-mcp --skill polymarket-tennis -a codex`. Or copy the skill folder (skills/polymarket-tennis in livetennisapi/livetennisapi-mcp) into .agents/skills/polymarket-tennis in your project. Codex loads it when a task matches its description.

Can I use Polymarket Tennis in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add livetennisapi/livetennisapi-mcp --skill polymarket-tennis -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/polymarket-tennis, .gemini/skills/polymarket-tennis, .github/skills/polymarket-tennis and .opencode/skills/polymarket-tennis in your project.

What does Polymarket Tennis need to run?

Going by SKILL.md and its folder, Polymarket Tennis needs the command-line tools its instructions call (pip and ruff) and credentials named LIVETENNIS_API_KEY and LIVETENNISAPI_KEY. Our summary lists: Python 3; A credential in LIVETENNIS_API_KEY; A credential in LIVETENNISAPI_KEY. Compatibility (from SKILL.md): Python 3.10+, pip install polymarket-tennis (single runtime dependency httpx). Live match data needs a free Live Tennis API key in LIVETENNIS_API_KEY; Polymarket Gamma and Kalshi market reads are keyless..

Does Polymarket Tennis access the network?

SKILL.md names 4 domains. In commands or code: livetennisapi.com; the agent is likely to contact it when it follows the instructions. As links in the text: blog.livetennisapi.com, github.com and docs.livetennisapi.com. This is read from the text; nothing was executed.

Is Polymarket Tennis safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Polymarket Tennis use?

Polymarket Tennis is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Polymarket Tennis use?

About 3k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.8k tokens, read only when the agent opens those files.

What are the alternatives to Polymarket Tennis?

Skills that share tags, products or a category with Polymarket Tennis: Okx Sentiment Tracker (dex-original/okx-agent-trade-kit, 110 stars), Tiger Brokers OpenAPI SDK (qusong0627/QuantMind, 1.7k stars), Web3 Polymarket (Polymarket/agent-skills, 192 stars) and Dr Manhattan (guzus/dr-manhattan, 204 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Polymarket Tennis?

livetennisapi (a GitHub organization) maintains it in livetennisapi/livetennisapi-mcp, which has 152 GitHub stars. The repository was last updated on October 7, 2026.

Source: livetennisapi/livetennisapi-mcp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.