# io.github.Ninjabeam20/sportiq-mcp (remote · sportiq.utkarshgupta.org)

MCP tools for FIFA World Cup 2026 football, Formula 1, and IPL cricket — sims, strategy, fantasy.

- Trust score: 78/100 (medium)
- Change this week: +60
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-24

## Components

- remote · `sportiq.utkarshgupta.org`: 78/100 (this document), [markdown](https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq.md), [page](https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq)
- pypi · `sportiq-mcp`: 62/100, [markdown](https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq-mcp.md), [page](https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq-mcp)

## Channel facts

- Endpoint: `https://sportiq.utkarshgupta.org/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.3.2`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-24.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 406, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 82/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6973 tokens (~154/item across 45 items; 44 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 73/100
  - Stability observed for 22 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 44 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 45 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.Ninjabeam20/sportiq-mcp server?

io.github.Ninjabeam20/sportiq-mcp is a hosted endpoint at https://sportiq.utkarshgupta.org/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ninjabeam20-sportiq-mcp 'https://sportiq.utkarshgupta.org/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "ninjabeam20-sportiq-mcp": {
      "url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ninjabeam20-sportiq-mcp": {
      "type": "http",
      "url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ninjabeam20-sportiq-mcp]
url = "https://sportiq.utkarshgupta.org/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ninjabeam20-sportiq-mcp": {
      "type": "remote",
      "url": "https://sportiq.utkarshgupta.org/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ninjabeam20-sportiq-mcp --url 'https://sportiq.utkarshgupta.org/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ninjabeam20-sportiq-mcp:
    url: "https://sportiq.utkarshgupta.org/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "ninjabeam20-sportiq-mcp": {
      "Transport": "http",
      "Url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ninjabeam20-sportiq-mcp -t streamable-http -u 'https://sportiq.utkarshgupta.org/mcp'
```

### Other

```json
{
  "mcpServers": {
    "ninjabeam20-sportiq-mcp": {
      "type": "http",
      "url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-23 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 67 to 70. That category is still filling its 30-day observation window: 20 days of observed history at the previous scan, 21 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-21 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63. That category is still filling its 30-day observation window: 18 days of observed history at the previous scan, 19 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-20 (score 76, +58)

- [security improvement] Injection markers: unverified → pass
- [security improvement] Authorization: unverified → partial
- [security improvement] Transport: fail → pass
- [functional improvement] Endpoint reachability: not serving MCP → reachable
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.60

### 2026-09-13 (score 18, −55)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Stability: 0.33 → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] Authorization: partial → unverified
- [security regression] Transport: pass → fail
- [functional regression] Schema quality: 100 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified

### 2026-09-12 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-11 (score 72, +54)

- [security improvement] Injection markers: unverified → pass
- [security improvement] Authorization: unverified → partial
- [security improvement] Transport: fail → pass
- [functional improvement] Endpoint reachability: not serving MCP → reachable
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.30

### 2026-09-10 (score 18, −53)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Authorization: partial → unverified
- [security regression] Stability: 0.23 → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] Transport: pass → fail
- [functional regression] Schema quality: 100 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified

### 2026-09-08 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (44)

### `sportiq_health` (~55 tokens)

Report cache backend, per-adapter healthcheck, and quota status.

Returns:
    HealthReport-shaped dict with `cache_backend`, `cache_ok`,
    `adapters` (per-source ok/detail), and `quotas`.

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_groups` (~92 tokens)

Return the FIFA World Cup 2026 group draw and advancement format.

Returns:
    data.groups: {group_letter: [4 team codes]} for all 12 groups.
    data.format: 48-team / 12-group / top-2 + 8-best-thirds rule.
    data.teams: team-code -> {name, fifa_code} metadata.
    meta.source: adapter that served the data.

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_fixtures` (~162 tokens)

Return World Cup 2026 fixtures (live providers, else the group schedule).

Args:
    limit: Max fixtures to return, 1..200 (default 50).
    offset: Number of fixtures to skip for paging (default 0).

Returns:
    data.fixtures: page of {home, away, date/group, status, home_goals, away_goals}.
    data.pagination: {total, count, offset, limit, has_more, next_offset}.
    meta.source: adapter that served the data (static_seed = group schedule only).

Input parameters:

- `limit` (integer): Max fixtures to return, 1..200 (default 50).
- `offset` (integer): Number of fixtures to skip for paging (default 0).

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_standings` (~148 tokens)

Return current World Cup 2026 group standings.

Args:
    limit: Max standing rows to return, 1..200 (default 50).
    offset: Number of rows to skip for paging (default 0).

Returns:
    data.standings: page of {rank, team, group, points, played, goals_diff}.
    data.pagination: {total, count, offset, limit, has_more, next_offset}.
    meta.source: adapter that served the data.

Input parameters:

- `limit` (integer): Max standing rows to return, 1..200 (default 50).
- `offset` (integer): Number of rows to skip for paging (default 0).

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_squad` (~131 tokens)

Return a national team's World Cup squad.

Args:
    team: Team code or name (e.g. "ARG"). Without an API-Football key, the
        static seed serves an empty-but-valid squad (rosters are a follow-up).

Returns:
    data.squad: list of {name, number, position, age}.
    meta.source: adapter that served the data.

Input parameters:

- `team` (string, required): Team code or name (e.g. "ARG"). Without an API-Football key, the static seed serves an empty-but-valid squad (rosters are a follow-up).

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_match_stats` (~130 tokens)

Return a team's aggregate World Cup tournament statistics.

Network-only enrichment: requires a configured API-Football (or
football-data.org) key. There is no offline static fallback, so without a
key the call returns a clean ALL_SOURCES_FAILED envelope.

Args:
    team: API-Football numeric team id (not a country code).

Returns:
    data.team_stats: {team, played, wins, goals_for, goals_against}.
    meta.source: adapter that served the data.

Input parameters:

- `team` (integer, required): API-Football numeric team id (not a country code).

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_top_scorers` (~52 tokens)

Return the World Cup 2026 top scorers.

Returns:
    data.scorers: list of {name, team, goals, assists}.
    meta.source: adapter that served the data.

Output parameters:

- `data`
- `error`
- `meta`

### `football_get_odds` (~178 tokens)

Return live market head-to-head odds for upcoming World Cup 2026 matches.

Sourced from The Odds API (requires THEODDS_KEY). Without a key the call
returns a clean ALL_SOURCES_FAILED envelope rather than crashing.

Args:
    team: Optional team name to filter events (case-insensitive substring,
        matched against both sides). Omit to return every WC event.

Returns:
    data.events: list of {event_id, home, away, commence_time, bookmakers:
        [{name, home, draw, away}]} with decimal 1X2 prices per bookmaker.
    meta.source: adapter that served the data (theodds / cache:stale).

Input parameters:

- `team`: Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every WC event.

Output parameters:

- `data`
- `error`
- `meta`

### `football_xg_model` (~157 tokens)

Estimate a match's expected goals and win/draw/loss probabilities.

Args:
    home_team: First team code (e.g. "ARG").
    away_team: Second team code (e.g. "BRA").
    neutral: True for a neutral venue (no home advantage). World Cup default.

Returns:
    data: {expected_home_goals, expected_away_goals, home_win, draw, away_win}.
    meta.estimated: true.

Input parameters:

- `away_team` (string, required): Second team code (e.g. "BRA").
- `home_team` (string, required): First team code (e.g. "ARG").
- `neutral` (boolean): True for a neutral venue (no home advantage). World Cup default.

Output parameters:

- `data`
- `error`
- `meta`

### `football_match_predictor` (~123 tokens)

Predict a single match: most likely scoreline + outcome probabilities.

Args:
    home_team: First team code.
    away_team: Second team code.
    neutral: True for a neutral venue (World Cup default).

Returns:
    data: {most_likely_score, home_win, draw, away_win, predicted_winner}.
    meta.estimated: true.

Input parameters:

- `away_team` (string, required): Second team code.
- `home_team` (string, required): First team code.
- `neutral` (boolean): True for a neutral venue (World Cup default).

Output parameters:

- `data`
- `error`
- `meta`

### `football_simulate_group` (~140 tokens)

Monte Carlo one group within the full 12-group qualification context.

Args:
    group: Group letter A-L.
    iterations: Number of simulations (clamped to 100..20000).

Returns:
    data.teams: Per-team position probabilities, p_auto_advance,
        p_best_third_advance, truthful combined p_advance, and avg_points.
    data.iterations: iterations actually run.
    meta.estimated: true. meta.conditioned_matches: completed matches locked in.

Input parameters:

- `group` (string, required): Group letter A-L.
- `iterations` (integer): Number of simulations (clamped to 100..20000).

Output parameters:

- `data`
- `error`
- `meta`

### `football_simulate_bracket` (~259 tokens)

Monte Carlo the full World Cup 2026 — per-team round + title probabilities.

Simulates all 12 groups, advances the top 2 + 8 best third-placed teams to a
32-team knockout, and plays it to a champion, ``iterations`` times.

Args:
    iterations: Number of tournament simulations (clamped to 100..20000;
        ~10000 gives stable ±2% probabilities).
    seed: Optional RNG seed for reproducible output.

Returns:
    data.teams: {code: {reach_r32, reach_r16, reach_qf, reach_sf, reach_final, win}}
        sorted by win probability descending.
    data.champion: most likely winner.
    data.iterations: iterations run.
    meta.estimated: true. meta.conditioned_matches: completed matches locked in
        (played group results fixed, decided knockout ties locked).

Example:
    football_simulate_bracket()
    football_simulate_bracket(iterations=20000, seed=42)

Input parameters:

- `iterations` (integer): Number of tournament simulations (clamped to 100..20000; ~10000 gives stable ±2% probabilities).
- `seed`: Optional RNG seed for reproducible output.

Output parameters:

- `data`
- `error`
- `meta`

### `football_knockout_path` (~142 tokens)

Round-by-round survival probabilities for one team in the full sim.

Args:
    team: Team code (e.g. "FRA").
    iterations: Number of tournament simulations (clamped to 100..20000).
    seed: Optional RNG seed.

Returns:
    data: {team, reach_r32, reach_r16, reach_qf, reach_sf, reach_final, win}.
    meta.estimated: true.

Input parameters:

- `iterations` (integer): Number of tournament simulations (clamped to 100..20000).
- `seed`: Optional RNG seed.
- `team` (string, required): Team code (e.g. "FRA").

Output parameters:

- `data`
- `error`
- `meta`

### `football_find_value_bets` (~327 tokens)

Surface the largest gaps between the model's win probability and the market.

De-vigs each market's 1X2 decimal odds (removes the margin so implied
probabilities sum to 1) and compares them to this server's own match-outcome
probabilities — the same Elo/Poisson path ``football_match_predictor`` uses.
Where the model probability exceeds the de-vigged market probability by at
least ``min_edge``, the outcome is flagged with its edge and the
model's fair odds.

Args:
    team: Optional team name to filter events (case-insensitive substring,
        matched against both sides). Omit to scan every WC 2026 odds event.
    min_edge: Minimum edge (model_prob - devigged_market_prob), 0..1.
        Default 0.05 (5 percentage points).

Returns:
    data.value_bets: list of {event_id, home, away, outcome, model_prob,
        fair_odds, market_odds, edge, bookmaker}, sorted by edge descending.
    data.events_analysed: events with both teams rated (model-comparable).
    meta.estimated: true. meta.is_stale reflects the odds freshness.

Input parameters:

- `min_edge` (number): Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05 (5 percentage points).
- `team`: Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to scan every WC 2026 odds event.

Output parameters:

- `data`
- `error`
- `meta`

### `football_form_trends` (~118 tokens)

Return rolling form, goal record, and xG trend for a football team.

Args:
    team: Team name (e.g. "Brazil", "Argentina").

Returns:
    data: {form_string, wins, draws, losses, goals_scored, goals_conceded,
           xg_for, xg_against, recent_trend, matches_analysed}.
    meta.estimated: true — derived from available fixture data.

Input parameters:

- `team` (string, required): Team name (e.g. "Brazil", "Argentina").

Output parameters:

- `data`
- `error`
- `meta`

### `football_build_accumulator` (~164 tokens)

Model the joint probability of several match outcomes from the top model-vs-market gaps.

Calls ``football_find_value_bets`` internally to fetch live odds, then selects
the strongest legs and combines them under the joint-probability model.

Args:
    legs: Number of legs (2-8). Default 3.
    min_edge: Minimum edge threshold per leg. Default 0.05.

Returns:
    data: {legs, legs_used, combined_odds, combined_model_prob, combined_edge,
           risk_flag, independence_warning}.
    meta.estimated: true.

Input parameters:

- `legs` (integer): Number of legs (2-8). Default 3.
- `min_edge` (number): Minimum edge threshold per leg. Default 0.05.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_sessions` (~117 tokens)

Return F1 sessions for a given year, optionally filtered by country.

Args:
    year: Championship year (e.g. 2025).
    country: Optional country name to filter (e.g. "Monaco").

Returns:
    data.sessions: list of session objects with session_key, session_type, date.
    meta.source: adapter that served the data.

Input parameters:

- `country`: Optional country name to filter (e.g. "Monaco").
- `year` (integer, required): Championship year (e.g. 2025).

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_drivers` (~76 tokens)

Return driver list for a specific F1 session.

Args:
    session_key: OpenF1 session identifier.

Returns:
    data.drivers: list of driver objects with driver_number, full_name, team.
    meta.source: adapter that served the data.

Input parameters:

- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_lap_times` (~240 tokens)

Return lap times for a driver in a specific F1 session.

Args:
    session_key: OpenF1 session identifier.
    driver_number: Driver's race number (e.g. 1 for Verstappen).
    limit: Max laps to return, 1..200 (default 100 — covers most full races).
    offset: Number of laps to skip for paging (default 0).

Returns:
    data.laps: page of lap objects with lap_number and lap_duration. OpenF1
        does not put compound/tyre_life here — those live on the stints endpoint.
    data.pagination: {total, count, offset, limit, has_more, next_offset}.
    meta.source: adapter that served the data.

Input parameters:

- `driver_number` (integer, required): Driver's race number (e.g. 1 for Verstappen).
- `limit` (integer): Max laps to return, 1..200 (default 100 — covers most full races).
- `offset` (integer): Number of laps to skip for paging (default 0).
- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_standings` (~93 tokens)

Return F1 driver and constructor championship standings for a year.

Args:
    year: Championship year (e.g. 2025).

Returns:
    data.driver_standings: driver championship positions and points.
    data.constructor_standings: constructor championship positions and points.
    meta.source: adapter that served the data.

Input parameters:

- `year` (integer, required): Championship year (e.g. 2025).

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_race_results` (~148 tokens)

Return the final classification for one F1 race, keyed by year and round.

Args:
    year: Championship year (e.g. 2025).
    round: Round number within the season (1-based; e.g. 1 for the opener).

Returns:
    data.results: Ergast/Jolpica RaceTable payload — finishing order, times,
        grid positions, points, and fastest laps for the race.
    meta.source: adapter that served the data.

Input parameters:

- `round` (integer, required): Round number within the season (1-based; e.g. 1 for the opener).
- `year` (integer, required): Championship year (e.g. 2025).

Output parameters:

- `data`
- `error`
- `meta`

### `f1_get_weather` (~72 tokens)

Return weather data for a specific F1 session.

Args:
    session_key: OpenF1 session identifier.

Returns:
    data.weather: list of weather snapshots with temperature, rainfall, wind.
    meta.source: adapter that served the data.

Input parameters:

- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_tyre_degradation` (~146 tokens)

Fit a tyre degradation model for a driver + compound in a session.

Args:
    session_key: OpenF1 session identifier.
    driver_number: Driver's race number.
    compound: Tyre compound (SOFT, MEDIUM, HARD, INTER, WET).

Returns:
    data: {intercept, slope, residual_std, sample_count}.
    meta.estimated: true — model output, not telemetry oracle.

Input parameters:

- `compound` (string, required): Tyre compound (SOFT, MEDIUM, HARD, INTER, WET).
- `driver_number` (integer, required): Driver's race number.
- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_undercut_window` (~144 tokens)

Estimate whether an undercut is viable for the attacker against the target.

Args:
    session_key: OpenF1 session identifier.
    attacker_number: Attacking driver's race number.
    target_number: Target driver's race number.
    current_lap: Current lap number in the race.

Returns:
    data: {laps_to_clear, viable, marginal}.
    meta.estimated: true.

Input parameters:

- `attacker_number` (integer, required): Attacking driver's race number.
- `current_lap` (integer, required): Current lap number in the race.
- `session_key` (integer, required): OpenF1 session identifier.
- `target_number` (integer, required): Target driver's race number.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_head_to_head_pace` (~121 tokens)

Compare lap-time pace distribution between two drivers in a session.

Args:
    session_key: OpenF1 session identifier.
    driver_a: First driver's race number.
    driver_b: Second driver's race number.

Returns:
    data: {driver_a_avg_s, driver_b_avg_s, delta_s, faster_driver}.
    meta.estimated: true.

Input parameters:

- `driver_a` (integer, required): First driver's race number.
- `driver_b` (integer, required): Second driver's race number.
- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_weather_strategy_impact` (~77 tokens)

Analyse weather data and recommend compound or pit-window adjustments.

Args:
    session_key: OpenF1 session identifier.

Returns:
    data: {has_rain, avg_track_temp_c, compound_recommendation, recommendation}.
    meta.estimated: true.

Input parameters:

- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_predict_pit_strategy` (~378 tokens)

Predict the optimal pit-stop strategy for a driver in an F1 race session.

Args:
    session_key: OpenF1 session identifier for a recorded race.
    driver_number: Driver's race number (e.g. 1 for Verstappen).
    current_lap: Current lap to project from (default 1 = full race ahead).
    total_laps: Total race laps. If omitted, inferred from the highest
        observed lap_number in the fetched laps (correct for Monaco 78 /
        Spa 44), falling back to 57 when no laps are available. An explicit
        value always wins.

Returns:
    data.stop_laps: recommended pit laps.
    data.compound_sequence: tyre compounds for each stint.
    data.expected_finish_position: currently always None (not modelled).
    data.confidence: 0.0-1.0 model confidence.
    meta.total_laps: race length used (explicit arg, else inferred from laps).
    meta.estimated: true.

Example:
    f1_predict_pit_strategy(session_key=9158, driver_number=1)
    f1_predict_pit_strategy(session_key=9158, driver_number=16, current_lap=20, total_laps=78)

Input parameters:

- `current_lap` (integer): Current lap to project from (default 1 = full race ahead).
- `driver_number` (integer, required): Driver's race number (e.g. 1 for Verstappen).
- `session_key` (integer, required): OpenF1 session identifier for a recorded race.
- `total_laps`: Total race laps. If omitted, inferred from the highest observed lap_number in the fetched laps (correct for Monaco 78 / Spa 44), falling back to 57 when no laps are available. An explicit value alway…

Output parameters:

- `data`
- `error`
- `meta`

### `f1_qualifying_analysis` (~135 tokens)

Analyse a qualifying session: best lap per driver, gap to pole, projected grid.

Args:
    session_key: OpenF1 session identifier for a Qualifying session.

Returns:
    data.grid: [{position, driver_number, full_name, team_name, best_lap_gap_s}].
    data.pole_time_s: pole lap duration in seconds.
    data.drivers_analysed: count of drivers with valid laps.
    meta.estimated: true — grid derived from session laps, not official timing.

Input parameters:

- `session_key` (integer, required): OpenF1 session identifier for a Qualifying session.

Output parameters:

- `data`
- `error`
- `meta`

### `f1_race_pace_compare` (~129 tokens)

Compare race-pace and tyre degradation between two F1 drivers in a session.

Args:
    session_key: OpenF1 session identifier.
    driver_a: First driver's race number.
    driver_b: Second driver's race number.

Returns:
    data: {by_compound, overall_faster, compounds_compared}.
    meta.estimated: true — degradation model fit, not official timing.

Input parameters:

- `driver_a` (integer, required): First driver's race number.
- `driver_b` (integer, required): Second driver's race number.
- `session_key` (integer, required): OpenF1 session identifier.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_live_matches` (~63 tokens)

Return all currently live cricket matches across all series.

Returns:
    data.matches: list of live match objects (team names, score, status).
    meta.source: which adapter served the response.
    meta.is_stale: true if data is from stale cache.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_scorecard` (~85 tokens)

Return the full scorecard for a specific match.

Args:
    match_id: The match identifier (e.g. from cricket_get_live_matches).

Returns:
    data: full scorecard with innings, partnerships, bowling figures.
    meta.source: adapter that served the data.

Input parameters:

- `match_id` (string, required): The match identifier (e.g. from cricket_get_live_matches).

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_points_table` (~100 tokens)

Return the points table / standings for a cricket series.

Args:
    series_id: The series identifier (e.g. IPL 2026 series ID from CricAPI).

Returns:
    data: points table rows with team, P, W, L, NRR, Points.
    meta.source: adapter that served the data.

Input parameters:

- `series_id` (string, required): The series identifier (e.g. IPL 2026 series ID from CricAPI).

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_schedule` (~189 tokens)

Return the upcoming match schedule, optionally filtered by series.

Args:
    series_id: Optional. Filter to a specific series. If omitted, returns
               all upcoming fixtures across all active series.
    limit: Max matches to return, 1..200 (default 50).
    offset: Number of matches to skip for paging (default 0).

Returns:
    data.matches: page of upcoming matches with teams, date, venue.
    data.pagination: {total, count, offset, limit, has_more, next_offset}.
    meta.source: adapter that served the data.

Input parameters:

- `limit` (integer): Max matches to return, 1..200 (default 50).
- `offset` (integer): Number of matches to skip for paging (default 0).
- `series_id`: Optional. Filter to a specific series. If omitted, returns all upcoming fixtures across all active series.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_squad` (~166 tokens)

Return the squad roster for a cricket team, optionally for a specific series.

Args:
    team: Team code or name (e.g. "MI", "CSK", "IND", "AUS").
    series_id: Optional. Series ID to pull the tournament-specific squad.
               If omitted, falls back to static seed data.

Returns:
    data.players: list of players with name, role, and credits.
    meta.source: adapter that served the data (cricapi / static_seed).

Input parameters:

- `series_id`: Optional. Series ID to pull the tournament-specific squad. If omitted, falls back to static seed data.
- `team` (string, required): Team code or name (e.g. "MI", "CSK", "IND", "AUS").

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_live_odds` (~237 tokens)

Return live market head-to-head odds for upcoming/live IPL matches.

Sourced from The Odds API (requires THEODDS_KEY). Without a key the call
returns a clean ALL_SOURCES_FAILED envelope rather than crashing.

Args:
    team: Optional team name to filter events (case-insensitive substring,
        matched against both sides). Omit to return every IPL event. The
        Odds API uses its own opaque event ids, so a CricAPI match_id
        cannot be resolved to an event yet — filtering is by team name.

Returns:
    data.events: list of {event_id, home, away, commence_time, bookmakers:
        [{name, home, away}]} with decimal h2h prices per bookmaker.
    meta.source: adapter that served the data (theodds / cache:stale).

Input parameters:

- `team`: Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every IPL event. The Odds API uses its own opaque event ids, so a CricAPI match_id cannot…

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_build_dream11_team` (~388 tokens)

Recommend an optimal fantasy XI + captain + vice-captain for one fixture.

Args:
    match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically.
    team_a: First team code/name (e.g. ``MI``). Required if match_id is absent.
    team_b: Second team code/name (e.g. ``CSK``). Required if match_id is absent.
    venue: Venue key/name (e.g. ``wankhede``). Required if match_id is absent.
    strategy: ``"balanced"`` only in Phase 2; future variants reserved.

Returns:
    data.players: 11 picked players with name/role/credits/team/projected_points.
    data.captain: name of the chosen captain.
    data.vice_captain: name of the chosen VC.
    data.total_credits: sum of credits used (<= 100).
    data.total_projected_points: fantasy points including C x2 and VC x1.5 boosts.
    meta.estimated: true — projections are model output, not a fantasy oracle.

Example:
    cricket_build_dream11_team(team_a="MI", team_b="CSK", venue="wankhede")
    cricket_build_dream11_team(match_id="abc123")

Input parameters:

- `match_id`: CricAPI match identifier; resolves team_a/team_b/venue automatically.
- `strategy` (string): ``"balanced"`` only in Phase 2; future variants reserved.
- `team_a`: First team code/name (e.g. ``MI``). Required if match_id is absent.
- `team_b`: Second team code/name (e.g. ``CSK``). Required if match_id is absent.
- `venue`: Venue key/name (e.g. ``wankhede``). Required if match_id is absent.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_captain_recommendation` (~198 tokens)

Return the top-3 captain candidates ranked by projected points.

Args:
    match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically.
    team_a: First team code/name. Required if match_id is absent.
    team_b: Second team code/name. Required if match_id is absent.
    venue: Venue key/name. Required if match_id is absent.

Returns:
    data.candidates: list of 3 dicts with name/role/team/projected_points.
    meta.source: model:captain_score.
    meta.estimated: true.

Input parameters:

- `match_id`: CricAPI match identifier; resolves team_a/team_b/venue automatically.
- `team_a`: First team code/name. Required if match_id is absent.
- `team_b`: Second team code/name. Required if match_id is absent.
- `venue`: Venue key/name. Required if match_id is absent.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_differential_picks` (~269 tokens)

Suggest low-ownership picks with positive projected upside.

Ownership is *estimated* — proxied by credit weight (lower-credit players
tend to have lower ownership), not real ownership data. Flagged
\``estimated: true`` in the response.

Args:
    match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically.
    team_a: First team code/name. Required if match_id is absent.
    team_b: Second team code/name. Required if match_id is absent.
    venue: Venue key/name. Required if match_id is absent.
    ownership_threshold: percent ownership cap; affects estimated label.

Returns:
    data.picks: list of {name, role, team, credits, projected_points,
        estimated_ownership_pct}.
    meta.source: model:captain_score (filtered).
    meta.estimated: true.

Input parameters:

- `match_id`: CricAPI match identifier; resolves team_a/team_b/venue automatically.
- `ownership_threshold` (integer): percent ownership cap; affects estimated label.
- `team_a`: First team code/name. Required if match_id is absent.
- `team_b`: Second team code/name. Required if match_id is absent.
- `venue`: Venue key/name. Required if match_id is absent.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_player_form_index` (~126 tokens)

Report a 0-100 form score for a player using the player_stats chain.

Args:
    player_id: Upstream player identifier (CricAPI/Cricbuzz id).

Returns:
    data.form_score: 0..100 indicator.
    data.trend: "rising" / "stable" / "falling".
    data.samples: how many recent innings were available.
    meta.source: which adapter served the underlying stats.
    meta.estimated: true.

Input parameters:

- `player_id` (string, required): Upstream player identifier (CricAPI/Cricbuzz id).

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_get_pitch_report` (~105 tokens)

Summarise pitch characteristics for a venue.

Args:
    venue: Venue key (e.g. ``wankhede``), official name, or city.

Returns:
    data: {batting_friendly 0..1, expected_first_inn, recommendation,
        venue, pitch_type}.
    meta.source: which adapter served the venue record.

Input parameters:

- `venue` (string, required): Venue key (e.g. ``wankhede``), official name, or city.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_find_value_bets` (~333 tokens)

Compare model probabilities against market-implied IPL odds. Requires THEODDS_KEY.

NOTE: cricket has no calibrated team-strength model wired yet (unlike the
football Elo/Poisson path), so this tool currently returns an EMPTY
\``value_bets`` list — scoring an edge against a neutral 50/50 prior would flag
every market underdog, which would be misleading. It
still reports how many events were screened so callers know odds were
available. For raw de-vigged prices use ``cricket_get_live_odds``. Real edge
detection lands when a cricket win model is wired (see cricket_head_to_head).

Args:
    team: Optional team name to filter events (case-insensitive substring).
        Omit to scan every IPL odds event.
    min_edge: Minimum edge (model_prob - devigged_market_prob), 0..1.
        Default 0.05. Currently informational only (no bets emitted).

Returns:
    data.value_bets: always ``[]`` until a cricket model is wired.
    data.events_analysed: count of events screened (both teams present).
    data.model: ``"neutral_baseline"``. data.note: why no bets are emitted.
    meta.estimated: true.

Input parameters:

- `min_edge` (number): Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05. Currently informational only (no bets emitted).
- `team`: Optional team name to filter events (case-insensitive substring). Omit to scan every IPL odds event.

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_head_to_head` (~171 tokens)

Compare two cricket teams head-to-head using squad form and player stats.

Args:
    team_a: First team code or name (e.g. "MI", "India").
    team_b: Second team code or name (e.g. "CSK", "Australia").

Returns:
    data: {team_a, team_b, team_a_edge_count, team_b_edge_count,
           key_players_a, key_players_b, h2h_win_rate_a, h2h_win_rate_b,
           win_prob_a, win_prob_b}.
    meta.estimated: true.

Input parameters:

- `team_a` (string, required): First team code or name (e.g. "MI", "India").
- `team_b` (string, required): Second team code or name (e.g. "CSK", "Australia").

Output parameters:

- `data`
- `error`
- `meta`

### `cricket_player_matchup` (~130 tokens)

Analyse the head-to-head matchup between two cricket players based on role and career stats.

Args:
    player_a: Player ID or name for the first player.
    player_b: Player ID or name for the second player.

Returns:
    data: {matchup_type, edge_holder, edge_reason, signals, role_a, role_b}.
    meta.estimated: true — heuristic model, not ball-by-ball H2H data.

Input parameters:

- `player_a` (string, required): Player ID or name for the first player.
- `player_b` (string, required): Player ID or name for the second player.

Output parameters:

- `data`
- `error`
- `meta`

### `cross_sport_build_accumulator` (~122 tokens)

Model the joint probability of multiple outcomes across football and cricket.

Args:
    legs: Total legs across both sports (2-8). Default 3.
    min_edge: Minimum edge per leg. Default 0.05.

Returns:
    data: same shape as football_build_accumulator, with sport field per leg.
    meta.estimated: true.

Input parameters:

- `legs` (integer): Total legs across both sports (2-8). Default 3.
- `min_edge` (number): Minimum edge per leg. Default 0.05.

Output parameters:

- `data`
- `error`
- `meta`

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq#diagnostics

## Score history

- 2026-09-24: 78
- 2026-09-23: 78
- 2026-09-22: 77
- 2026-09-21: 77
- 2026-09-20: 76
- 2026-09-19: 18
- 2026-09-18: 18
- 2026-09-17: 18
- 2026-09-16: 18
- 2026-09-15: 18
- 2026-09-14: 18
- 2026-09-13: 18
- 2026-09-12: 73
- 2026-09-11: 72
- 2026-09-10: 18
- 2026-09-09: 71
- 2026-09-08: 71
- 2026-09-07: 70
- 2026-09-06: 70
- 2026-09-05: 69
- 2026-09-04: 69
- 2026-09-03: 68
- 2026-09-02: 68

## Common questions

### What is the io.github.Ninjabeam20/sportiq-mcp server?

io.github.Ninjabeam20/sportiq-mcp is listed in the public MCP registry as io.github.Ninjabeam20/sportiq-mcp. MCP tools for FIFA World Cup 2026 football, Formula 1, and IPL cricket, sims, strategy, fantasy. This page covers its hosted endpoint (https://sportiq.utkarshgupta.org/mcp).

### Is the io.github.Ninjabeam20/sportiq-mcp server safe to use?

io.github.Ninjabeam20/sportiq-mcp scores 78 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.Ninjabeam20/sportiq-mcp server expose?

io.github.Ninjabeam20/sportiq-mcp exposes 44 tools: sportiq_health, football_get_groups, football_get_fixtures, football_get_standings, football_get_squad, and 39 more. Their descriptions and schemas cost roughly 6,936 tokens of context every time the server is loaded.

### Does the io.github.Ninjabeam20/sportiq-mcp server require authentication?

No. We connected to io.github.Ninjabeam20/sportiq-mcp without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the io.github.Ninjabeam20/sportiq-mcp server still maintained?

io.github.Ninjabeam20/sportiq-mcp is still listed as active in the MCP registry. We last reached this channel on 24 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://sportiq.utkarshgupta.org/mcp
- Repository: https://github.com/Ninjabeam20/SportIQ-MCP
- Changelog RSS feed: https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq.xml
- Changelog JSON feed: https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq.json
- HTML version of this page: https://verifymcp.io/servers/ninjabeam20-sportiq-mcp/sportiq