This MCP server reads live Australian racing and sports odds, schedules and results — it cannot place bets or modify accounts.
Racing: next races to jump with every bookmaker's price per runner, best odds per runner, upcoming race schedule, settled results, and market movers (firming/drifting).
Sports: list available sports, get odds from multiple bookmakers, and find the single best price per selection.
Account: check monthly credit usage and remaining balance.
Data freshness: every response includes data age, per-price timestamps, and stale flags so you can see how current the odds are.
Read-only: no bet placement, no bookmaker credentials, and no account or billing changes.
Provides live Betfair Exchange odds for Australian racing and sports events, enabling comparison with other bookmakers.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@puntersedge-mcp What's the next race at Randwick and who's favourite?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol server for Australian horse racing, greyhound, harness and sports odds. Point Claude Desktop, Claude Code, Cursor, Windsurf or any MCP client at a live Australian odds feed and ask it what is racing next, what every bookmaker is paying, which runners are firming, and who won.
Racing data MCP · sports odds MCP server · horse racing MCP server · Australian odds for Claude · sports data for Cursor.
You: What's the next race at Randwick and who's favourite?
→ racing_next_to_go(num_races=3, country="AU")
← Wiesners Maiden Plate R1 — 11 runners, 8 bookmakers, data 38s old
Favourite: <runner> at $2.40 (sportsbet) / $2.55 (tab) / $2.35 (neds)14 Australian bookmakers on racing. AU thoroughbred, greyhound and harness; NZ thoroughbred and harness. AFL, NRL, NBA, NFL, tennis, cricket and more on sports. Free tier: 3,000 credits a month, no card.
Being straight about this, because the difference is large.
| This repo (TypeScript) | |
Tools | 26 | 9 |
Credit cost stated per tool | yes, all 26 | no |
Works before you have an API key | yes — two keyless demo tools | no |
Form, premierships, closing lines, track conditions, feed health | yes | no |
Install |
|
|
Docs | this file |
If you just want the odds inside your assistant, use the Python server. It is the fuller server, it is the one the documentation describes, and it will show you live prices before you sign up for anything.
This TypeScript server is a smaller, dependency-light implementation of the five core racing tools and four sports tools. It is real and it works — the install below is verified — but it is a subset.
{
"mcpServers": {
"puntersedge": {
"command": "uvx",
"args": ["puntersedge-mcp"],
"env": { "PUNTERSEDGE_API_KEY": "your_key_here" }
}
}
}Full instructions: https://puntersedge.online/developers/mcp-server?utm_source=github&utm_medium=readme
Related MCP server: sportsdata-mcp
Not published to npm. There is no npm package called puntersedge-mcp — install straight
from this repo, which builds itself on install:
npx -y github:Propertyscout001/puntersedge-mcpFirst run clones the repo and compiles it with tsc, so it takes a while and needs git plus
a working Node toolchain. Node ≥18.
Get a free API key at https://puntersedge.online/api?utm_source=github&utm_medium=readme — 3,000 credits a month, no credit card.
Edit claude_desktop_config.json, then fully quit and reopen Claude Desktop:
OS | Path |
macOS |
|
Windows |
|
Linux |
|
{
"mcpServers": {
"puntersedge": {
"command": "npx",
"args": ["-y", "github:Propertyscout001/puntersedge-mcp"],
"env": { "PUNTERSEDGE_API_KEY": "your_key_here" }
}
}
}One command, from the project directory:
claude mcp add puntersedge \
-e PUNTERSEDGE_API_KEY=your_key_here \
-- npx -y github:Propertyscout001/puntersedge-mcpAdd -s user to make it available in every project instead of just this one. Claude Code
writes project servers to .mcp.json in the project root, which you can commit and edit by
hand — keep the key out of it and use an environment variable if you do.
.cursor/mcp.json for one project, ~/.cursor/mcp.json for all of them:
{
"mcpServers": {
"puntersedge": {
"command": "npx",
"args": ["-y", "github:Propertyscout001/puntersedge-mcp"],
"env": { "PUNTERSEDGE_API_KEY": "your_key_here" }
}
}
}~/.codeium/windsurf/mcp_config.json — same mcpServers shape as Cursor.
.vscode/mcp.json in the workspace. VS Code uses a servers key rather than mcpServers:
{
"servers": {
"puntersedge": {
"type": "stdio",
"command": "npx",
"args": ["-y", "github:Propertyscout001/puntersedge-mcp"],
"env": { "PUNTERSEDGE_API_KEY": "your_key_here" }
}
}
}Any host that accepts a stdio server takes the same three facts: a command, its arguments, and
an env block carrying PUNTERSEDGE_API_KEY. Keep the key in the environment, not in a prompt —
the server reads it once at start-up and never echoes it in a tool result.
Nine tools, all read-only. Costs are in API credits and are what the API bills for the underlying endpoint — they are not this server's invention. Figures below were read from https://api.puntersedge.online/openapi.json on 2026-09-15.
Tool | What it returns | Cost |
| The next AU races about to jump, with every bookmaker's price per runner. The primary tool. | 2 credits |
| Just the best available price per runner, and which book is offering it. | 3 credits |
| The upcoming schedule — venues, race numbers, jump times. No prices, so cheaper. | 1 credit |
| Settled results and dividends for races already run. | 2 credits |
| Runners firming or drifting sharply across the market. | 3 credits |
Tool | What it returns | Cost |
| Every sport and | 1 credit |
| Odds for one sport across the bookmakers covering it. | 1 credit per market requested — |
| Best price per selection for one sport. | 3 credits |
Tool | What it returns | Cost |
| Credits used and remaining this month. | free |
Every response also carries the live X-Credits-* headers through to the tool result, so an
assistant can read its remaining balance without spending a call to find out. A 402 means the
monthly allowance is spent — a hard stop, no overage billing — and the tool result says so
rather than failing quietly.
There is no horse-racing sport key. Racing lives under the racing_* tools. Passing
sport_key="horse-racing" to a sports tool is an error.
Worth being explicit, because "betting odds" and "AI agent" in one sentence invites the wrong assumption.
It can:
read a live odds feed — current per-bookmaker prices, the upcoming schedule, settled results, and which runners are firming or drifting
tell you how fresh each number is, per price, not per page
state what each call costs in credits before it makes it, and report the balance after
It cannot:
place a bet. There is no tool here that places, stakes, cancels or settles anything. Every tool is an HTTP GET against a read-only endpoint.
hold or use bookmaker credentials. This server has no bookmaker account, no login, no session with any bookmaker. It reads published prices. The only secret it touches is your PuntersEdge API key, read from the environment and never written to a tool result.
change your PuntersEdge account. Key rotation, billing and webhook registration are all deliberately left out, so a chat turn cannot rotate your credentials, change what you are billed, or register a URL that then receives your data. Those endpoints exist; reach them from application code or the dashboard, on purpose.
predict a result. Prices are what bookmakers published. Nothing here forecasts outcomes, rates a runner, or tells you what to back.
It will sometimes be wrong about the market, and the data says so. A stalled scraper does
not error — it keeps serving its last value, which looks exactly like a live price. Every quote
carries its own age_seconds and a stale flag for that reason. A large apparent edge on a
market only one bookmaker is quoting is a data artefact, not an opportunity; check how many
books stand behind a price before treating a gap as real.
Racing responses carry the full market per runner:
{
"race_name": "Wiesners Maiden Plate", "race_number": 1, "venue": "...",
"category": "horse", "country": "AU", "distance_m": 1200,
"track_condition": "...", "weather": "...", "places_paid": 3,
"data_age_seconds": 38, "stale": false, "stale_bookmakers": [],
"scratchings": [],
"runners": [{
"name": "...", "number": 1, "barrier": 4,
"jockey": "...", "trainer": "...", "weight": 58.0, "form": "11521",
"bookmakers": [
{ "key": "tabtouch", "win_price": 126.0, "place_price": 12.0,
"tote_win": {"PROV": 60.6}, "last_update": "2026-08-17T02:55:3...",
"source_url": "https://www.tabtouch.com.au/racing/..." }
]
}]
}Every response tells you its own age. data_age_seconds is race-level, each bookmaker entry
carries its own last_update, and stale_bookmakers names the specific legs that have gone
quiet rather than condemning the whole race. That matters when an assistant is about to state a
price as fact — it can say how fresh the number is instead of implying it is live to the second.
Racing: 14 Australian bookmakers — BetRight, Sportsbet, Betr, TAB, Ladbrokes, Neds, Unibet, PointsBet, NextBet, TABtouch, Palmerbet, BetDeluxe, BetGold and BoostBet. The live count and per-book freshness are published at https://puntersedge.online/coverage-report?utm_source=github&utm_medium=readme.
Betfair and Pinnacle are not in this feed. The Betfair Exchange is ingested but its prices are withheld from customer responses pending a Betfair data licence, so it is not counted above and you will never see a Betfair price through this server. If you need exchange prices, this is not the feed for you.
Bookmaker keys in the API are not always the brand: NextBet is returned as playup, its
name before rebranding. Filter on the key, not the display name.
Near the jump, coverage is broad and fairly even. Measured over 13 days of captured snapshots — 3,339 Australian races, each within 30 minutes of jumping — every one of the fourteen sources quoted between 75% and 97% of them: TABtouch 97%, PointsBet 96%, then Sportsbet, Neds, Palmerbet, Ladbrokes, BetRight, Betr and TAB all clustered at 80–82%, Unibet 79% and NextBet 75%.
Books publish markets at different times, so a race several hours out often carries only two or three prices where more appear closer to the jump. Every response names the books that actually quoted, so you can read the real depth per race rather than trusting an average.
Sports: fewer again. At most 5 bookmakers on AFL and NRL, 3 on NBA and ATP, and as few as 1 on some competitions. That is a connector-coverage limit, not an outage. Racing is where this feed is strongest, and the tools say so rather than implying a uniform market.
Pass country=AU for racing. 87% of foreign and unlabelled races carry exactly one
bookmaker, so there is usually nothing to compare — but "usually" is the honest word: over the
same 13 days, 10% carried two books and a small tail (about 3%) carried eleven. Check
bookmakers per race rather than assuming either way.
An Australian race gathers books as it approaches the jump, so its depth is a range, not a
number. Measured 2026-08-17: a median of 10 bookmakers inside 30 minutes of the jump, 9 at
30–60 minutes, 5 at one to two hours, and 2 beyond that. racing_next_to_go returns imminent
races, so it sits at the deep end of that range — which is why a headline average across the
whole feed understates what you actually get back.
How much of the card is foreign swings with the clock rather than sitting at some headline ratio:
near zero through the Australian afternoon, all of it overnight. Filter on country rather than
assuming a mix.
Not exposed: arbitrage and exchange endpoints. Some are withheld pending a Betfair licence and return 410 to customer keys, so shipping tools for them would only produce errors.
This is data, not advice. Prices are what bookmakers published; nothing here predicts outcomes, and nothing here places a bet.
Endpoints and parameters were enumerated from the live openapi.json, not from memory.
Pricing — free tier 3,000 credits/month
Postman collection — import into Postman via Import → Link
18+ only. Gambling can be addictive — please gamble responsibly. Gambling Help: 1800 858 858, or Gambling Help Online.
MIT © PuntersEdge
This API key's credit usage and remaining balance for the month. Use it when a call has been refused with a 402, or when the user asks how much of their quota is left.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral disclosure. It implicitly indicates a read-only operation by describing credit usage remaining balance, but it does not explicitly state the operation is non-mutating or mention potential limitations (e.g., rate limits). The description is adequate for a simple query tool but leaves some behavioral aspects unstated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the tool's purpose and immediately followed by explicit usage conditions. Every word earns its place—no repetition or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description is fully sufficient. It covers what the tool provides (credit usage and remaining balance) and when to invoke it, making it complete for an agent to select and use without further clarification.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty (0 parameters), so the baseline is 4. The description adds no parameter-specific details because none exist; it correctly describes the tool as having no inputs, so no additional semantic value is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reports 'this API key's credit usage and remaining balance for the month,' which is specific and distinguishes it from the sports-related sibling tools. Though it lacks an explicit verb, the intent (returning account usage) is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit when-to-use guidance is provided: 'Use it when a call has been refused with a 402, or when the user asks how much of their quota is left.' This gives clear context and directly instructs the agent on appropriate invocation scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The single best price per selection for one sport, and which bookmaker offers it. Use when the user wants the best available price rather than every book's line.
| Name | Required | Description | Default |
|---|---|---|---|
| sport_key | Yes | From list_sports, e.g. 'afl'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the core behavioral trait (returns single best price and bookmaker per selection), which is useful context beyond the schema. It doesn't mention details like return format or pagination, but for a simple read-only tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler. The first sentence states the output, the second provides usage guidance. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a single required parameter fully documented in the schema and no output schema, the description adequately explains the return value (best price and bookmaker per selection). It could add more detail about selection scope (e.g., all selections for the sport), but is largely complete for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers the sole parameter 'sport_key' with a description and example, giving 100% coverage. The description adds only 'for one sport', which reinforces but doesn't meaningfully extend the schema's meaning. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('get') and clearly states the tool returns 'the single best price per selection for one sport' and 'which bookmaker offers it'. It distinguishes from alternatives by contrasting with 'every book's line'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use when the user wants the best available price rather than every book's line', providing a clear use case. It implies when-not but doesn't name a specific alternative tool, so a slight deduction from 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Head-to-head and other market odds for one sport, from every bookmaker covering it. Use for 'odds for the game', 'who is favourite in the NRL tonight'. Sports coverage is thinner than racing — at most 5 bookmakers on AFL and NRL, 3 on NBA and ATP, and as few as 1 on some competitions — so say how many books are quoting rather than implying a full market.
| Name | Required | Description | Default |
|---|---|---|---|
| markets | No | Comma-separated market keys, e.g. 'h2h,totals'. | |
| sport_key | Yes | From list_sports, e.g. 'afl', 'nrl', 'nba'. | |
| bookmakers | No | Restrict to these bookmaker keys. | |
| oddsFormat | No | Default decimal (Australian convention). | |
| maxAgeMinutes | No | Drop prices older than this. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses a key behavioral limitation: bookmaker coverage varies widely (as few as 1 bookmaker on some competitions) and instructs the agent to report the number of books rather than implying full market. It does not address other behaviors like response structure, pagination, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with each earning its place: purpose, usage examples, and a caveat. High signal-to-noise ratio and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description omits how odds are returned (e.g., a list of games versus a single event), and the example 'odds for the <team> game' implies event-level filtering that the schema does not support (only sport_key). Without an output schema, the agent lacks guidance on response shape. The thin-coverage caveat is helpful but not sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All five parameters are fully described in the schema with examples and defaults, so the description adds little parameter-level detail. It does reinforce the concept of 'from every bookmaker' relevant to the bookmakers parameter, but the baseline 3 applies because the schema already carries the load.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns head-to-head and other market odds for a single sport from all covering bookmakers, with concrete example queries. It distinguishes itself from racing tools by noting that sports coverage is thinner.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit use-case examples ('odds for the <team> game', 'who is favourite in the NRL tonight') and implies this is for sports rather than racing. However, it does not name sibling tools or explicitly state when to prefer racing_best_odds or get_best_odds.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Every sport and competition this API currently covers, with its sport_key. Call this FIRST if you are unsure of the right sport_key — passing an unknown key returns a 404 listing the valid ones, but checking here is cheaper. Note there is no 'horse-racing' sport_key: racing lives under the separate racing_* tools.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses what the tool returns (sport_key for all sports) and explicitly notes that 'horse-racing' is absent, directing to racing_* tools. However, it does not detail the exact return structure (e.g., array format), which is a minor gap for a no-arg list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences: purpose, usage, and a critical caveat. Every sentence adds value, and the purpose is front-loaded. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter list tool, the description is complete: it states what is returned, when to use it, and a notable exclusion (horse-racing). It also references sibling tools, providing enough context for an agent to select and invoke it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, so the parameter semantics baseline is 4. The description adds no parameter-specific information, but none is needed since the schema is empty and the description focuses on the tool's purpose and output.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: "Every sport and competition this API currently covers, with its sport_key." It uses the verb 'list' implicitly and identifies the exact resource (sports/competitions) and output field (sport_key), making it distinct from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided: "Call this FIRST if you are unsure of the right sport_key" and "checking here is cheaper" than relying on a 404 from other tools. It also clarifies the alternative for racing (separate racing_* tools), giving clear when-to-use and when-not-to-use context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The single best available price for each runner in upcoming Australian races, and which bookmaker is offering it. Use this when the user wants the best price rather than a full comparison across every book — 'where is the best odds on ', 'best price in the next race'.
| Name | Required | Description | Default |
|---|---|---|---|
| country | No | ISO country codes, e.g. 'AU'. | |
| num_races | No | How many upcoming races. Default 10. | |
| bookmakers | No | Restrict to these bookmaker keys. | |
| categories | No | horse, greyhound, harness — comma-separated. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It discloses the output (best price per runner and bookmaker) and scope (upcoming Australian races), but lacks detail on data sources, edge cases (e.g., no races found), or any other behavioral nuances. It is clear it is a read-only lookup, but adds only basic context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, starting with the core purpose in the first sentence and following with two practical example queries. It contains no filler or redundant information, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple query tool with no output schema and no annotations, the description covers the main outputs (best price and bookmaker), the scope (upcoming Australian races), and example usage. It does not describe return format, but the examples and clear purpose make it sufficient for most agent interactions. Minor gaps include handling of multiple categories or bookmaker restrictions, which are covered by the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents all four parameters. The description adds context about the tool's intent (best price) but does not enrich the meaning of individual parameters beyond what the schema already provides. Therefore, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: providing 'the single best available price for each runner in upcoming Australian races' and the offering bookmaker. It distinguishes itself from a full-comparison tool by saying 'Use this when the user wants the best price rather than a full comparison across every book,' which sets it apart from siblings like get_best_odds.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool: 'Use this when the user wants the best price rather than a full comparison across every book.' It also provides concrete example phrasings ('where is the best odds on <horse>', 'best price in the next race'), making it easy for an agent to recognize relevant user requests.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The upcoming Australian race schedule — venues, race numbers and jump times, without runner prices. Use this for 'what meetings are on today' or to find a race_id before asking about it. Cheaper than next_to_go when prices are not needed.
| Name | Required | Description | Default |
|---|---|---|---|
| country | No | ISO country codes, e.g. 'AU'. | |
| categories | No | horse, greyhound, harness — comma-separated. | |
| hours_ahead | No | Look-ahead window in hours. Default 4. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states that runner prices are not included and that the tool is cheaper than the alternative, which are important behavioral traits. It does not mention output format or error handling, but for a simple read-only schedule tool, the disclosure is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the core content in the first sentence and usage guidance in the second. Every part adds value with no filler or redundancy, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity tool with three well-schema-covered parameters and no output schema, the description provides all necessary context: what the tool returns, what it excludes, when to use it, and how it compares to a sibling. The description is complete enough for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides full descriptions for all three parameters (country, categories, hours_ahead), so the baseline is 3. The description adds minimal parameter-specific insight beyond implying a look-ahead window via 'what meetings are on today', which maps to hours_ahead. It does not compensate for any gaps since there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource ('upcoming Australian race schedule') and the specific content (venues, race numbers, jump times) while explicitly excluding runner prices. It distinguishes itself from sibling tools like racing_next_to_go by noting the cost difference and lack of prices, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: 'Use this for "what meetings are on today" or to find a race_id before asking about it.' It also names an alternative (next_to_go) and tells when this tool is preferable ('Cheaper than next_to_go when prices are not needed'), providing clear context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Runners whose price has moved sharply across the market — firming (shortening) or drifting (lengthening). Use this for 'what's being backed', 'any big movers today', or market-sentiment questions. A move confirmed by several bookmakers is more meaningful than one book repricing, so min_books guards against reading noise as a signal.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max runners returned. | |
| country | No | ISO country codes, e.g. 'AU'. | |
| direction | No | Omit for both. | |
| min_books | No | How many bookmakers must show the move before it counts. Default 3. | |
| categories | No | horse, greyhound, harness. | |
| min_move_pct | No | Minimum percentage move. Default 10. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden of behavioral disclosure. It adds meaningful context by explaining that a move confirmed by multiple bookmakers is more reliable and that min_books prevents false signals, but it does not disclose return format, latency, rate limits, or edge cases like no results or partial data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: purpose, usage context, and a practical nuance. Front-loaded with the core definition, no filler, and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 6 parameters but no output schema. The description covers purpose, usage scenarios, and a critical domain concept (multi-book confirmation). It doesn't explain what the output looks like or how to combine parameters, but given sibling tools and schema coverage, it is reasonably complete for a data-retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description goes further by giving purpose to min_books ('guards against reading noise as a signal') and by clarifying the direction semantics through 'firming (shortening) or drifting (lengthening)', which adds value beyond the schema's enum labels.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly captures purpose with a specific verb-resource: 'Runners whose price has moved sharply across the market — firming (shortening) or drifting (lengthening).' It also alludes to distinct use cases ('what's being backed', 'any big movers today') without confusing it with sibling tools like racing_best_odds or racing_results.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use the tool: 'Use this for "what's being backed", "any big movers today", or market-sentiment questions.' It provides a key conceptual guideline about min_books confirming moves, though it stops short of naming alternative tools or saying when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The next Australian horse, greyhound and harness races about to jump, with EVERY bookmaker's price for every runner side by side. This is the primary tool: use it for 'what's racing next', 'who is favourite in the next race at ', or any question about current Australian racing prices. Each race reports data_age_seconds and each price its own age, so you can tell the user how fresh the odds are rather than implying they are live to the second.
| Name | Required | Description | Default |
|---|---|---|---|
| country | No | ISO country codes, comma-separated, e.g. 'AU' or 'AU,NZ'. Pass AU for Australian meetings — about one upcoming race in five is foreign or unlabelled and carries a median of ONE bookmaker, which makes price comparison meaningless. AU races carry a median of four. | |
| num_races | No | How many upcoming races to return. Default 10. | |
| bookmakers | No | Comma-separated bookmaker keys to restrict to, e.g. 'sportsbet,tab'. | |
| categories | No | Comma-separated: horse, greyhound, harness. Omit for all three. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It goes beyond the obvious by explaining that each race reports data_age_seconds and each price its own age, allowing the agent to accurately describe freshness instead of implying live-to-the-second data. This is meaningful added context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both dense with purpose and usage. The first defines the exact output, the second provides example queries and a behavioral note. No wasted words, and the key differentiation ('primary tool') is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with no output schema, the description covers the core: what races are returned, the bookmaker/runner format, and data freshness. It could optionally mention that results are sorted by start time or include pagination, but for a simple 'next to go' endpoint, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema already provides rich guidance (e.g., the country parameter explains why passing AU is important and gives bookmaker count statistics). The description adds no parameter-level semantics beyond what the schema already offers, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the next Australian horse, greyhound, and harness races with every bookmaker's price for every runner. It then gives concrete example questions ('what's racing next', 'who is favourite in the next race at <venue>') that distinguish it from price-comparison or historical-result tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'This is the primary tool' and lists precise use cases for current Australian racing prices. It stops short of naming sibling tools as alternatives or stating when not to use it, so it misses the explicit exclusion guidance seen in the top calibration example.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Settled results for Australian races that have already run — finishing order and dividends. Use this for 'who won the at ' or to check a past result. Not for upcoming races.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max races returned. | |
| venue | No | Filter to one venue, e.g. 'Randwick'. | |
| categories | No | horse, greyhound, harness. | |
| hours_back | No | How far back to look. Default 24. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral transparency burden. It adds useful context (settled, already run, finishing order and dividends) but does not disclose read-only safety, default lookback window, or availability limitations beyond what the schema already implies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no wasted words. The first sentence states core functionality and output, the second provides usage context and an exclusion. Well front-loaded and easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema, it explains the return content (finishing order/dividends) and filters by context. However, it omits that results are only available for a limited lookback window (hours_back max 168, default 24), which could mislead an agent expecting arbitrary historical results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; limit, venue, categories, and hours_back are already fully documented in the input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description explicitly states it provides 'Settled results for Australian races that have already run — finishing order and dividends' and clarifies the use case ('who won the <race> at <venue>'). It also distinguishes from siblings by noting 'Not for upcoming races.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear when-to-use examples ('who won...' or 'check a past result') and an explicit exclusion ('Not for upcoming races'). However, it does not name a specific alternative tool such as racing_next_to_go, which would make the guidance stronger.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0account_usageget_best_oddsget_sports_oddslist_sportsracing_best_oddsracing_eventsracing_moversracing_next_to_goracing_resultsScored across 9 tools
Each tool has a distinct purpose, but racing_next_to_go and racing_best_odds both cover upcoming racing prices, and get_best_odds vs racing_best_odds have similar names across domains. Descriptions clearly distinguish all-bookmakers from best-price, so misselection risk is low.
Tool names mix verb-based patterns (get_, list_) for sports and account with a racing_* prefix for all racing tools. The racing_* group is internally consistent, but the overall set lacks a uniform verb_noun convention, making the naming somewhat inconsistent.
With 9 tools, the server is well-scoped for a betting odds API covering both sports and racing. Each tool covers a distinct function with no obvious bloat or redundancy.
The API covers account usage, sports odds (all and best), racing schedule, live prices, best odds, movers, and results. A minor gap is the lack of a direct way to fetch odds for a specific race by ID, relying instead on next-to-go or best-odds for upcoming races.
Hosted MCP server for live public-data APIs and Skills for AI agents.
Read-only MCP server for live Polymarket, Kalshi, Limitless odds; Manifold sentiment.
Your agent needs the crowd's number — live odds on elections, policy, macro prints and sport, from the venues where people put money behind the opinion. **What you can ask for** • "What are the current odds on this event?" • "List the open markets on this topic across both venues." • "Show recent trades and how the price moved." • "What is the implied probability now versus a week ago?" **How to use it** Point any MCP client at https://mcp.aisa.one/prediction-market-data/mcp and sign in with OAuth — there is no key to create or paste. 5 tools: Kalshi markets and trades, Polymarket markets, events and activity. **Why this rather than the source** Both venues in one shape, so the same question can be priced twice. **It is also a door to the rest** The same login reaches 26 sources and 580+ operations. Read the odds here, then ask the same agent for the market data or the news behind them — without adding a second server. **What it costs** Finding and inspecting an operation is free. Running one is billed per call at API prices, with no seat and no monthly minimum, and every call takes max_price_usd so an agent cannot overspend by accident. **Where else it reaches** https://mcp.aisa.one/finance/mcp for equities, crypto and prediction markets in one place.
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
