soccer-mcp
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., "@soccer-mcpsettle my picks for yesterday's matches"
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.
soccer-mcp
An MCP server that gives AI agents football fixtures, real results, bet settlement and honest odds arithmetic — one day, every competition, no API key.
Most football MCP servers wrap a paid data API and stop at "here is a list of matches". This one ships the part that is usually missing: turning a price into a verdict. It de-vigs a market, compares your probability against the offered odds, names the minimum price worth taking, sizes the stake and settles the result against the real scoreline — including push and quarter-line handling that most quick scripts get wrong.
Tools
Tool | What it answers |
| Every football match on a day, all competitions, with scores once played |
| Finished matches with final score — the input for settling |
| Settle a list of picks against real scorelines: per-pick result, hit rate, PnL, ROI |
| Strip the bookmaker margin and return the market's own probabilities |
| Fair odds, EV, minimum odds, scaled Kelly stake, take-it verdict |
| Combined odds/EV of an accumulator and how fast the edge decays per leg |
| Whether the optional private engine bridge is wired up |
Related MCP server: betbetter-mcp
Install
pip install soccer-mcp # or: uvx soccer-mcpRun it as a stdio MCP server:
soccer-mcpUse with a client
Claude Desktop / Cursor / any MCP client (mcp.json):
{
"mcpServers": {
"soccer": {
"command": "uvx",
"args": ["soccer-mcp"],
"env": { "SOCCER_MCP_CACHE": "/tmp/soccer-mcp-cache" }
}
}
}With Docker:
{
"mcpServers": {
"soccer": { "command": "docker", "args": ["run", "-i", "--rm", "soccer-mcp"] }
}
}Private tools (premium tier)
The public package stays keyless and free. A private deployment attaches its own tools — paid feeds, sharp lines, model blending — through a plugin hook, so one server exposes both tiers:
SOCCER_MCP_PLUGINS=soccer_engine.mcp_tools,/opt/private/pro_tools.py soccer-mcpEach plugin is a module (dotted path or file path) with a register(server) function that adds tools to
the same server. Nothing private enters this repository, and engine_status() reports what is loaded.
SOCCER_ENGINE_PATH optionally points at a private engine directory to bridge into.
Environment
Variable | Default | Meaning |
|
| Where day scoreboards are cached |
|
| Cache seconds for the current day |
|
| Cache seconds for past days (scores never change) |
| unset | Operator-only: path to a private analysis engine to bridge into |
Example
evaluate_price(probability=0.55, odds=1.95, margin_pct=3)
→ fair_odds 1.818, ev_pct +7.25, minimum_odds 1.873, take_it true, stake.scaled_kelly_pct 3.75
settle_picks(picks=[{"home": "VfB Stuttgart", "away": "Borussia Dortmund",
"market": "O2.5", "odds": 1.29, "date": "2026-09-18"}])
→ score "0:1", result "loss", profit -1.0, roi_pct -100.0Data source and limits
Fixtures and results come from ESPN's public day scoreboard (all competitions, one request per day, cached). Requests carry no custom User-Agent — ESPN answers 403 to every custom UA. Date ranges are rejected by that endpoint, so the server fetches by day.
Competition names are not part of the "all competitions" payload — each event only carries an ESPN
league id. The server therefore builds an id -> name map once (74 leagues, roughly 45 s, cached for
30 days via SOCCER_MCP_LEAGUE_TTL) and enriches each match with it. Competitions outside that map
keep an empty name, so every match also carries league_id and can still be grouped. The league
argument of get_fixtures/get_results is a case-insensitive substring filter: "Bundesliga"
matches the German and the Austrian one — pass league_id when you need certainty.
Know what this is not: the fixtures feed has no odds, no lineups and no xG. get_fixtures and
get_results are free public data; the arithmetic tools take your own probability as input and
never invent one. Nothing here promises profit: every model estimate is yours, and a positive
expected value on a handful of picks is noise.
Development
python -m venv .venv && . .venv/bin/activate
pip install -e ".[dev]"
pytest -q # odds arithmetic and settlement logic
python tests/smoke_stdio.py # end-to-end: real tool calls over stdio
docker build -t soccer-mcp . && \
printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"c","version":"1"}}}\n' | docker run -i --rm soccer-mcpWorks on both MCP SDK generations: the server imports MCPServer (v2) and falls back to FastMCP
(v1), and every tool returns JSON text, which both versions hand to the client unchanged.
License
MIT — see LICENSE.
Available Tools
7 toolsdevig_marketA
Strip the bookmaker margin from one market's prices and return the market's own probabilities.
Args: prices: the decimal prices of all outcomes of the same market, e.g. [1.75, 3.6, 4.4] for 1X2
| Name | Required | Description | Default |
|---|---|---|---|
| prices | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It clearly states that the tool strips margin and returns probabilities, implying a pure calculation with no side effects. It doesn't explicitly state read-only behavior, but the nature of the operation makes that obvious. It also clarifies the input format (decimal prices) which is helpful.
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 a single, front-loaded sentence stating the purpose, followed by a clear parameter explanation. Every word earns its place; no fluff or redundancy.
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 single-parameter calculation tool with an output schema available, the description fully explains the input and the conceptual output. It doesn't need to describe the return format since the output schema covers that. There are no missing details an agent would need to invoke it 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?
Schema description coverage is 0%, so the description must compensate. It does: it explains that 'prices' are decimal prices of all outcomes of the same market and provides a concrete example ([1.75, 3.6, 4.4] for 1X2), adding meaning far beyond the raw 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?
The description states a specific action (strip bookmaker margin) on a specific resource (one market's prices) and clearly differentiates from siblings like evaluate_price or parlay_math by focusing on devigging a single market. The example clarifies the intended use.
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 makes the purpose clear and it's obvious this is the only tool for devigging among the siblings, but it doesn't explicitly mention alternatives or when not to use it. The context is clear enough for an agent to select it correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
engine_statusA
Report whether the optional private analysis engine and private plugins are wired up.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It states the tool 'reports' status, implying a read-only operation, but does not explicitly mention safety, side effects, error conditions, or required setup. This is a minimal disclosure that leaves the agent to infer behavior.
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 a single, concise sentence that conveys the essential purpose with no fluff or redundant information. It is appropriately sized for the tool's simplicity.
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 an output schema (not shown here) and no parameters, so the description only needs to convey what the tool does. It does that clearly. It does not mention potential nuances like what happens if components are not configured, but the output schema likely covers return details. Overall, it is sufficient for a simple status check.
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 zero parameters, so the input schema is empty and the description coverage is trivially 100%. With no parameters, there is nothing to describe; the baseline of 4 for zero-parameter tools 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 action: 'Report whether' a specific subject ('optional private analysis engine and private plugins') are wired up. It is specific about the resource and distinguishes it from all sibling tools, which deal with betting data and calculations.
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 implies a diagnostic usage—checking the wiring status of optional components—but does not explicitly state when to use this tool versus alternatives. Since there are no obvious siblings that perform a similar status check, the context is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evaluate_priceA
Judge a price against your own probability: fair odds, EV, minimum odds and a scaled Kelly stake.
Args: probability: your probability for the outcome, e.g. 0.55 (not 55) odds: the decimal price on offer, e.g. 1.90 margin_pct: how much better than fair a price must be before you take it kelly_fraction: stake scaling; 0.25 means quarter Kelly
| Name | Required | Description | Default |
|---|---|---|---|
| odds | Yes | ||
| margin_pct | No | ||
| probability | Yes | ||
| kelly_fraction | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose all behavioral traits. It clarifies input formats (probability as decimal, not percentage) and parameter semantics, but it does not explicitly state that the tool is non-destructive or has no side effects. For a calculation tool, this is acceptable but not fully transparent about output behavior.
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, front-loaded with a one-line summary, and uses a clear Args block. Every sentence adds value, with 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?
The description covers the tool's purpose, all parameters, and example formats. An output schema exists, so return values are not required. Minor gaps like input range validation (probability between 0 and 1, odds >1) are not mentioned, but these are likely enforced elsewhere or implied. Overall, sufficient for an agent to invoke it 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?
Schema coverage is 0%, so the description fully compensates by explaining each parameter: probability as a decimal, odds as decimal price, margin_pct as the required edge, and kelly_fraction as stake scaling. It adds meaning well beyond the schema's bare names and defaults.
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 states a clear action ('Judge a price against your own probability') and lists the computed outputs (fair odds, EV, minimum odds, scaled Kelly stake). This distinguishes it from siblings like devig_market and parlay_math, which address different betting calculations.
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 purpose implies usage for single-price evaluation, but there is no explicit guidance on when to choose this over alternatives (e.g., devig_market for market-wide vig removal). No when-not conditions are stated, leaving some inference to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fixturesA
All football fixtures of one day (YYYY-MM-DD) across every competition, with scores when played.
Args: date: ISO date, e.g. 2026-09-20 league: optional case-insensitive substring filter on the competition name only_finished: only return matches with a final score
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | ||
| league | No | ||
| only_finished | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It discloses the broad scope, the conditional inclusion of scores, and the effect of only_finished. It does not mention edge cases like timezone handling or live-match behavior, but these are secondary for a read-only fixtures query.
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 main behavior is front-loaded in one clear sentence, followed by a compact parameter list where each line adds meaningful detail. There is no filler or redundant repetition of schema types.
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?
All three parameters are explained, an output schema exists, and the tool's scope is unambiguous. The only notable gap is the absence of a brief pointer to a sibling tool like get_results when result-specific data is needed, but that is not required to call this 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?
Schema description coverage is 0%, and the description fully compensates: date gets an ISO format with an explicit example, league is defined as a case-insensitive substring filter on the competition name, and only_finished is explained as returning only matches with a final score.
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 names a specific operation: retrieving all football fixtures for one date across every competition, with scores when played. It states the resource and scope clearly, and the date-focused framing helps distinguish it from result- or bet-oriented siblings.
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?
It clearly establishes when to use the tool: when a caller wants all fixtures for a single day, optionally filtered by league or finished matches. It does not explicitly contrast it with get_results or state when not to use it, so it stops short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_resultsA
Finished matches with final score for one day — the input for settling bets.
Args: date: ISO date, e.g. 2026-09-20 league: optional substring filter on the competition name
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | ||
| league | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It conveys a read-style retrieval of final scores and adds the 'input for settling bets' context, but it does not explicitly state read-only guarantees, permissions, or pagination behavior, so the disclosure is adequate but not rich.
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?
One front-loaded purpose sentence plus a compact Args block; every line adds information and there is no 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 two-parameter query with an output schema, the description covers the date scope, league filtering, and the downstream use case. It lacks an explicit pointer to get_fixtures for non-finished matches, but the 'finished matches' framing largely compensates.
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 coverage is 0%, so the description must explain the parameters, and it does: date is specified as an ISO date with an example, and league is described as an optional substring filter. This goes beyond the schema's bare type and default information.
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 states that the tool returns finished matches with final scores for a single day and identifies it as the input for settling bets, which clearly distinguishes it from get_fixtures. The verb and resource scope are specific enough for an agent to know exactly what it retrieves.
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?
It clearly specifies the context — one day's finalized results, with an optional league filter — and ties it to the settle_picks workflow. It does not explicitly name when to use get_fixtures instead, but 'finished matches' implies the contrast with upcoming fixtures.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parlay_mathB
Combined odds and EV of an accumulator, plus how fast the edge decays with each leg.
Args: legs: e.g. [{"probability": 0.6, "odds": 1.8}, {"probability": 0.5, "odds": 2.0}]
| Name | Required | Description | Default |
|---|---|---|---|
| legs | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior, but it only states what is computed. It does not mention side effects, error handling, assumptions about odds format, or the meaning of 'edge decay' beyond the phrase. This is insufficient for a tool with a complex input.
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 with the primary purpose. The args example is helpful, though presented informally rather than as a structured spec. Overall, it is efficient and easy to parse.
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 a single parameter that is a free-form array of objects, yet the description only gives an example. It does not define required fields, acceptable ranges, or how the output is structured (though an output schema exists). An agent may struggle to correctly construct valid input beyond the given example.
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 offers zero description for the 'legs' array items, but the description provides a concrete example showing the expected structure (probability and odds per leg). This adds some value beyond the empty schema, though it does not fully specify all possible fields or constraints.
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 computes combined odds, EV, and edge decay for an accumulator, with a specific verb and resource. This distinguishes it from siblings like get_fixtures or evaluate_price, which serve different purposes.
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?
No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites, scenarios, or exclusions, leaving the agent to infer usage solely from the name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
settle_picksA
Settle a list of picks against the real scorelines and return per-pick results plus totals.
Each pick: {"home": "...", "away": "...", "market": "O2.5", "odds": 1.75, "date": "2026-09-20"} Supported markets: O/U lines (1.0-4.5, quarter lines included), BTTS, 1X2, 2X2, DC. Team names are matched fuzzily against the day's fixtures, so slight spelling differences are fine.
Args: picks: list of picks, each needing home, away, market and odds date: fallback ISO date when a pick carries no date of its own
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | ||
| picks | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is the only behavioral disclosure, and it provides useful traits: supported markets, fuzzy team-name matching, fallback date handling, and the output shape. It leaves edge behaviors implicit, such as how unmatched picks are treated and whether anything is persisted, so it is not a 5.
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 tightly structured: purpose sentence, a worked pick example, market list, matching note, and an Args block. It is front-loaded and every sentence contributes.
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 moderate-complexity settlement tool, it covers input shape, market domain, matching tolerance, and date fallback, while the output schema covers return values. Slightly more detail on unmatched picks and exact market encodings would make it fully complete.
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 coverage is 0%, but the description compensates by documenting each pick's required fields with a concrete JSON example and explaining the optional date fallback. It stops short of listing exact accepted strings for every market and any odds constraints, which is the main gap.
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 first sentence names a concrete action ('settle'), the object ('list of picks'), the data source ('real scorelines'), and the output ('per-pick results plus totals'). This clearly distinguishes it from siblings like get_results and get_fixtures, even without naming them.
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 makes the invocation context clear: pass picks that need settling and an optional fallback date, and it resolves them against the day's fixtures. It does not include explicit when-not-to-use guidance or name alternatives, so it misses the top tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v0.1.0- First observed
devig_market - First observed
engine_status - First observed
evaluate_price - First observed
get_fixtures - First observed
get_results - First observed
parlay_math - First observed
settle_picks
TDQS
Scored across 7 tools
get_fixtures and get_results overlap substantially—get_results is essentially the finished-match subset of get_fixtures with only_finished enabled—so agents could misselect between them. The other tools are mostly distinct, especially the betting math tools, though devig_market and evaluate_price both deal with odds and probabilities and require careful reading of their descriptions.
Most names follow a clear verb_noun snake_case pattern: get_fixtures, get_results, settle_picks, devig_market, evaluate_price. Minor deviations include engine_status and parlay_math, which are noun-centric rather than imperative, but the overall style remains readable and predictable.
Seven tools is a well-scoped size for a soccer betting analytics server. Each tool has a clear role in the workflow, from fetching fixtures and results to settling picks, devigging odds, evaluating prices, and computing parlay math.
The core betting workflow is well covered: data retrieval, pick settlement, margin removal, price evaluation, and parlay calculations. Minor gaps exist around current odds fetching and league/team metadata, but agents can work around these since most math tools accept prices and probabilities as inputs.
Maintenance
Related MCP Connectors
Football fixtures, standings, and odds intelligence for AI agents.
Historical football results, draws and no-draw streaks. 11 read-only tools, 6 need no API key.
Grounded sports predictions plus European soccer and tennis arbitrage data for AI agents.
Sports odds, player props and source coverage for AI assistants. Connect with your own API key.
Related MCP Servers
AlicenseAqualityAmaintenanceEnables AI assistants to access sports betting odds data from 265+ bookmakers across 34 sports, including events, odds, historical data, arbitrage, and value bets.2282 npm1MIT- AlicenseAqualityCmaintenanceProvides AI assistants with sports model win probabilities and fair odds across nine sports without requiring an API key.360 npmMIT
- AlicenseAqualityBmaintenanceEnables AI assistants to query live football data, including fixtures, live scores, standings, statistics, betting odds, and full odds movement history for corner and card lines.1124 npmMIT
- AlicenseBqualityCmaintenanceProvides AI agents with live, grounded sports data including model probabilities, track records, and European soccer and tennis arbitrage opportunities, so they answer from real numbers instead of stale guesses.1348 npm1MIT