Koskamo

AlphaPipeline MCP

A pay-per-call data API for AI trading agents providing pre-trade security checks, Polymarket odds, and on-chain market data on Base without requiring signup or API keys.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

AlphaPipeline MCP logo, by parkyucheol-delCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by parkyucheol-del
You need:no signup, no API key, no OAuth
MCP endpoint (Streamable HTTP)
https://alphapipeline-eu.onrender.com/mcp
Vendor documentation

What its tools do

30 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

30 of 30 have a description · 30 of 30 declare behavior hints · 27 of 27 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Run pre-flight rug-pull and honeypot checks before on-chain swaps
  • Query Polymarket L2 VWAP and HIP-4 odds for prediction markets
  • Analyze DEX liquidity slippage and cross-venue arbitrage spreads
  • Retrieve derivatives funding rates and whale position audits

Source and maintenance

Community listingRegistry 1.3.0
Maintenance checked

Protocol and capabilities

Server
alphapipeline-mcp 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
30 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {},
  "extensions": {
    "io.modelcontextprotocol/events": {
      "status": "experimental",
      "methods": [
        "events/list",
        "events/subscribe",
        "events/unsubscribe"
      ]
    }
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Every AlphaPipeline tool must be paid per call in USDC on Base mainnet (x402 'exact' scheme). Each tool's _meta.x402 field in tools/list carries its price, network, and recipient address. Calling tools/call without payment makes this request's own HTTP response come back as 402, with an x402 accepts array in the body (price, asset, recipient address, nonce, and everything else needed to pay) - build an EIP-3009 transferWithAuthorization signature, attach it as the X-PAYMENT header, and retry the same request. Plain human chat UIs such as stock Claude Desktop/Cursor have no wallet of their own and cannot settle this payment automatically - this server is meant for agent/bot code equipped with an x402 payment interceptor (x402-httpx, x402-fetch, etc.).

Tools

30 advertised

market.kimchi_alert
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool when evaluating Korean exchange price premiums, the 'kimchi premium', Upbit price gaps vs a global reference price, cross-border crypto arbitrage, or sudden Korea-specific price anomalies. Real-time Upbit vs Coinbase spot (CoinGecko fallback) - NOT a live Binance orderbook, despite the legacy binance_price_usdt field name kept for backward compatibility - with reverse-premium and surge alerts. Do not use for general USD spot prices or on-chain DEX swaps. Paid in USDC on Base (free while KIMCHI_ALERT_ENABLED=false).

market.kimchi_alert input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "symbol": {
      "type": "string",
      "description": "Crypto ticker symbol to check, e.g. BTC, ETH, SOL. Defaults to BTC."
    }
  }
}
market.kimchi_alert output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "symbol",
    "upbit_price_krw",
    "binance_price_usdt",
    "usdkrw_rate_estimate",
    "kimchi_premium_pct",
    "premium_change_1h_pct",
    "alerts",
    "thresholds"
  ],
  "properties": {
    "alerts": {
      "type": "object",
      "required": [
        "reverse_premium",
        "premium_surge_1h"
      ],
      "properties": {
        "reverse_premium": {
          "type": "boolean"
        },
        "premium_surge_1h": {
          "type": "boolean"
        }
      }
    },
    "notice": {
      "type": "string"
    },
    "symbol": {
      "type": "string"
    },
    "thresholds": {
      "type": "object",
      "required": [
        "reverse_premium_pct",
        "surge_1h_pct"
      ],
      "properties": {
        "surge_1h_pct": {
          "type": "number"
        },
        "reverse_premium_pct": {
          "type": "number"
        }
      }
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "upbit_price_krw": {
      "type": "number"
    },
    "cex_price_source": {
      "type": "string"
    },
    "binance_price_usdt": {
      "type": "number",
      "description": "Legacy field name kept for backward compatibility - NOT a live Binance price, see notice/cex_price_source."
    },
    "kimchi_premium_pct": {
      "type": "number"
    },
    "usdkrw_rate_estimate": {
      "type": "number"
    },
    "premium_change_1h_pct": {
      "type": "number"
    },
    "cex_reference_price_usdt": {
      "type": "number",
      "description": "Same value as binance_price_usdt under an honestly-named field."
    }
  }
}
market.kimchi_alert annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
tools.ai_markdown
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool when an agent needs to parse clean webpage article content without wasting context tokens on ads, scripts, navigation, and HTML boilerplate, or when summarizing a specific URL. Converts any URL into clean Markdown optimized for LLM context windows. Do not use for raw API endpoints or binary files (PDF/images). Paid in USDC on Base.

tools.ai_markdown input schema
{
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Full http(s) URL of the webpage to convert to Markdown."
    }
  }
}
tools.ai_markdown output schema
{
  "type": "object",
  "required": [
    "url",
    "title",
    "markdown",
    "char_count"
  ],
  "properties": {
    "url": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "markdown": {
      "type": "string"
    },
    "char_count": {
      "type": "integer"
    }
  }
}
tools.ai_markdown annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
security.token_risk
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool before executing any on-chain swap to verify if an ERC-20 contract is a honeypot, rug-pull risk, or has malicious buy/sell taxes and mintability backdoors. GoPlus/Honeypot.is-backed security audit for a given contract address - beyond is_honeypot, also surfaces individual GoPlus risk signals (cannot_buy, cannot_sell_all, hidden_owner, transfer_pausable, selfdestruct, is_blacklisted, slippage_modifiable, owner_percent) into risk_flags, plus is_proxy/trading_cooldown as informational-only fields (not flagged, since both are common in legitimate contracts). All of these are null when the Honeypot.is fallback path is used. Do not use for market price discovery or liquidity depth. Paid in USDC on Base.

security.token_risk input schema
{
  "type": "object",
  "required": [
    "chain_id",
    "contract_address"
  ],
  "properties": {
    "chain_id": {
      "type": "integer",
      "description": "EVM chain id, e.g. 8453 for Base."
    },
    "contract_address": {
      "type": "string",
      "description": "Token contract address (0x...)."
    }
  }
}
security.token_risk output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "chain_id",
    "contract_address",
    "risk_level",
    "risk_flags",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "chain_id": {
      "type": "integer"
    },
    "is_proxy": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Informational only - does not feed risk_flags."
    },
    "is_in_dex": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "cannot_buy": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "risk_level": {
      "type": "string"
    },
    "token_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "buy_tax_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "is_honeypot": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "is_mintable": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "hidden_owner": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "holder_count": {
      "type": [
        "integer",
        "null"
      ]
    },
    "selfdestruct": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "sell_tax_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "token_symbol": {
      "type": [
        "string",
        "null"
      ]
    },
    "owner_address": {
      "type": [
        "string",
        "null"
      ]
    },
    "owner_percent": {
      "type": [
        "number",
        "null"
      ],
      "description": "Owner's % of total supply, GoPlus-only. Feeds 'high_owner_concentration' risk_flag at >=50%."
    },
    "is_blacklisted": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "is_open_source": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "cannot_sell_all": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "owner_renounced": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "contract_address": {
      "type": "string"
    },
    "trading_cooldown": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Informational only - does not feed risk_flags."
    },
    "transfer_pausable": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    },
    "slippage_modifiable": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "GoPlus-only, null on Honeypot.is fallback. Feeds risk_flags."
    }
  }
}
security.token_risk annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
security.contract_health_audit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to check whether a token's liquidity pool is locked, burned, or freely held by a single wallet before trusting its liquidity - a rug-pull signal that security.token_risk does not cover. Reuses the same GoPlus data as token_risk (no extra upstream call) and rolls it up into a liquidity_health category (LOCKED/PARTIALLY_LOCKED/UNLOCKED/NO_LP_DATA). Does not include any qualitative 'suspicious transaction' judgment - only GoPlus's own lock/burn numbers. Do not use for honeypot or tax checks (use security.token_risk) or market price data. Paid in USDC on Base.

security.contract_health_audit input schema
{
  "type": "object",
  "required": [
    "chain_id",
    "contract_address"
  ],
  "properties": {
    "chain_id": {
      "type": "integer",
      "description": "EVM chain id, e.g. 8453 for Base."
    },
    "contract_address": {
      "type": "string",
      "description": "Token contract address (0x...)."
    }
  }
}
security.contract_health_audit output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "chain_id",
    "contract_address",
    "liquidity_health",
    "risk_flags",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "chain_id": {
      "type": "integer"
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "token_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "token_symbol": {
      "type": [
        "string",
        "null"
      ]
    },
    "lp_burned_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "lp_locked_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "lp_holder_count": {
      "type": [
        "integer",
        "null"
      ]
    },
    "lp_total_supply": {
      "type": [
        "number",
        "null"
      ]
    },
    "contract_address": {
      "type": "string"
    },
    "liquidity_health": {
      "type": "string"
    },
    "top_unlocked_holder_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "top5_unlocked_holder_pct": {
      "type": [
        "number",
        "null"
      ],
      "description": "Sum of the top 5 non-locked/non-burned LP holders - catches concentration spread across several wallets that top_unlocked_holder_pct (single largest holder only) would miss."
    }
  }
}
security.contract_health_audit annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
security.token_prescreen
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to cheaply drop obviously-bad candidates out of a batch before spending the pricier security.token_risk / security.token_diagnostic calls on survivors - built for exactly the high-volume new-pool screening pattern where most candidates fail a basic liquidity/LP-lock check anyway. Combines GoPlus's LP lock/burn status (same underlying call as security.contract_health_audit, no extra upstream cost) with GeckoTerminal's top-pool USD liquidity (same source as dex.liquidity_slippage) into one minimal response. Does NOT check honeypot/tax/mint risk and does NOT give the full LP-holder breakdown - use security.token_risk / security.contract_health_audit for that. liquidity_usd is null when chain_id isn't mapped to a GeckoTerminal network (currently Base, Ethereum, BSC, Polygon, Arbitrum, Optimism, Avalanche). Paid in USDC on Base.

security.token_prescreen input schema
{
  "type": "object",
  "required": [
    "chain_id",
    "contract_address"
  ],
  "properties": {
    "chain_id": {
      "type": "integer",
      "description": "EVM chain id, e.g. 8453 for Base."
    },
    "contract_address": {
      "type": "string",
      "description": "Token contract address (0x...)."
    }
  }
}
security.token_prescreen output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "chain_id",
    "contract_address",
    "liquidity_health",
    "risk_flags",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "chain_id": {
      "type": "integer"
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "liquidity_usd": {
      "type": [
        "number",
        "null"
      ],
      "description": "Top pool's aggregate USD liquidity from GeckoTerminal (same source as dex.liquidity_slippage) - null when chain_id isn't mapped to a GeckoTerminal network, or no pool was found."
    },
    "contract_address": {
      "type": "string"
    },
    "liquidity_health": {
      "type": "string",
      "description": "Same categories/thresholds as security.contract_health_audit's own liquidity_health: LOCKED / PARTIALLY_LOCKED / UNLOCKED / NO_LP_DATA / UNKNOWN."
    }
  }
}
security.token_prescreen annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
security.token_authenticity
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to check whether a contract impersonates a known mainstream asset (e.g. a fake 'USDC'), using GoPlus's fake_token/trust_list/honeypot_with_same_creator fields - same underlying token_security call as security.token_risk / contract_health_audit / token_prescreen, no extra upstream cost. flagged_as_counterfeit=false is NOT proof of authenticity - it only means GoPlus found no such flag at query time. true_token_address is only set when flagged_as_counterfeit is true. No honeypot/tax/LP checks here - use security.token_risk / security.contract_health_audit for those. Paid in USDC on Base.

security.token_authenticity input schema
{
  "type": "object",
  "required": [
    "chain_id",
    "contract_address"
  ],
  "properties": {
    "chain_id": {
      "type": "integer",
      "description": "EVM chain id, e.g. 8453 for Base."
    },
    "contract_address": {
      "type": "string",
      "description": "Token contract address (0x...)."
    }
  }
}
security.token_authenticity output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "chain_id",
    "contract_address",
    "risk_flags",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "chain_id": {
      "type": "integer"
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "token_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "trust_list": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "True when GoPlus's trust_list flags this contract as a known, trustworthy token. Sparsely populated - absent/false does not imply risk."
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "token_symbol": {
      "type": [
        "string",
        "null"
      ]
    },
    "contract_address": {
      "type": "string"
    },
    "true_token_address": {
      "type": [
        "string",
        "null"
      ],
      "description": "Only non-null when flagged_as_counterfeit is true - GoPlus's claimed address of the genuine asset being impersonated, on the same chain."
    },
    "flagged_as_counterfeit": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "True when GoPlus's fake_token.value == 1. False means no such flag was found (not proof of authenticity). Null only when the GoPlus lookup itself failed."
    },
    "honeypot_with_same_creator": {
      "type": [
        "integer",
        "null"
      ],
      "description": "Count of other honeypot-flagged tokens deployed by the same creator address, per GoPlus."
    }
  }
}
security.token_authenticity annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
security.token_diagnostic
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool right before buying or swapping an unfamiliar token when you need a single-call combined security check: runs security.token_risk and security.contract_health_audit in parallel against the same GoPlus data and returns both, plus a deduped union of risk_flags and a plain risk_flags_count. Deliberately does not compute a composite score or letter grade - every field is copied unchanged from the two underlying tools. Cheaper than calling both separately. Do not use for token unlock/vesting risk (use unlocks.dump_risk) or if you only need one of the two checks (call that tool directly and pay less). Paid in USDC on Base.

security.token_diagnostic input schema
{
  "type": "object",
  "required": [
    "chain_id",
    "contract_address"
  ],
  "properties": {
    "chain_id": {
      "type": "integer",
      "description": "EVM chain id, e.g. 8453 for Base."
    },
    "contract_address": {
      "type": "string",
      "description": "Token contract address (0x...)."
    }
  }
}
security.token_diagnostic output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "chain_id",
    "contract_address",
    "liquidity_health",
    "risk_flags",
    "risk_flags_count",
    "checks_completed",
    "checks_total",
    "data_sources"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "chain_id": {
      "type": "integer"
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "token_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "buy_tax_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "is_honeypot": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "is_mintable": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "checks_total": {
      "type": "integer"
    },
    "data_sources": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "holder_count": {
      "type": [
        "integer",
        "null"
      ]
    },
    "sell_tax_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "token_symbol": {
      "type": [
        "string",
        "null"
      ]
    },
    "lp_burned_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "lp_locked_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "is_open_source": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "owner_renounced": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "checks_completed": {
      "type": "integer"
    },
    "contract_address": {
      "type": "string"
    },
    "liquidity_health": {
      "type": "string"
    },
    "risk_flags_count": {
      "type": "integer"
    },
    "top_unlocked_holder_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "top5_unlocked_holder_pct": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
security.token_diagnostic annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
derivatives.funding_rate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool when analyzing perpetual futures funding rates, long/short market sentiment crowding, or timing hedging strategies before settlement periods. Aggregates Bybit (primary) and Binance (fallback) perpetual funding rates, plus mark_price/index_price (both paths) and open_interest_usd (Bybit path only - null on the Binance fallback). Do not use for spot market volume or token security checks. Paid in USDC on Base.

derivatives.funding_rate input schema
{
  "type": "object",
  "required": [
    "symbol"
  ],
  "properties": {
    "symbol": {
      "type": "string",
      "description": "Ticker symbol, e.g. BTC, ETH, or BTCUSDT."
    }
  }
}
derivatives.funding_rate output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "symbol",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "symbol": {
      "type": "string"
    },
    "mark_price": {
      "type": [
        "number",
        "null"
      ],
      "description": "Perpetual futures mark price at lookup time. Populated on both the Bybit and Binance paths."
    },
    "data_source": {
      "type": "string"
    },
    "index_price": {
      "type": [
        "number",
        "null"
      ],
      "description": "Underlying spot index price feeding the perpetual's funding calculation. Populated on both the Bybit and Binance paths."
    },
    "funding_rate": {
      "type": [
        "number",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "predicted_rate": {
      "type": [
        "number",
        "null"
      ]
    },
    "next_funding_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "open_interest_usd": {
      "type": [
        "number",
        "null"
      ],
      "description": "Total open interest in USD notional. Only available via the Bybit path - always null on the Binance fallback, since Binance's premiumIndex endpoint does not report open interest."
    },
    "funding_interval_hours": {
      "type": [
        "integer",
        "null"
      ]
    },
    "funding_rate_percentage": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
derivatives.funding_rate annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
derivatives.funding_rate_value
Advertised by the server during the last successful anonymous check.
Advertised read-only

Cheapest-tier thin wrapper around derivatives.funding_rate - use this when you only need the funding rate number itself (decimal and percentage), not mark_price/index_price/open_interest_usd. Same Bybit-primary/Binance-fallback data. Paid in USDC on Base.

derivatives.funding_rate_value input schema
{
  "type": "object",
  "required": [
    "symbol"
  ],
  "properties": {
    "symbol": {
      "type": "string",
      "description": "Ticker symbol, e.g. BTC, ETH, or BTCUSDT."
    }
  }
}
derivatives.funding_rate_value output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "symbol",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "symbol": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "funding_rate": {
      "type": [
        "number",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "funding_rate_percentage": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
derivatives.funding_rate_value annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
derivatives.funding_apr_matrix
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to evaluate a spot+perpetual carry trade: annualizes the current perpetual funding rate into an APR, flags which side (SHORT or LONG perp) currently collects funding, and computes how many days of that funding income it takes to recoup an assumed round-trip trading cost. Pure calculation on top of funding_rate data - no extra upstream call. Do not use for the raw current funding rate alone (use derivatives.funding_rate) or for spot price data. Paid in USDC on Base.

derivatives.funding_apr_matrix input schema
{
  "type": "object",
  "required": [
    "symbol"
  ],
  "properties": {
    "symbol": {
      "type": "string",
      "description": "Ticker symbol, e.g. BTC, ETH, or BTCUSDT."
    },
    "assumed_round_trip_cost_pct": {
      "type": "number",
      "description": "Combined entry+exit trading fee percentage across both the spot and perpetual legs. Defaults to 0.2."
    }
  }
}
derivatives.funding_apr_matrix output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "symbol",
    "assumed_round_trip_cost_pct",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "symbol": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "breakeven_days": {
      "type": [
        "number",
        "null"
      ]
    },
    "periods_per_year": {
      "type": [
        "integer",
        "null"
      ]
    },
    "annualized_rate_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "funding_collector_side": {
      "type": [
        "string",
        "null"
      ]
    },
    "funding_interval_hours": {
      "type": [
        "integer",
        "null"
      ]
    },
    "funding_rate_percentage": {
      "type": [
        "number",
        "null"
      ]
    },
    "daily_funding_income_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "assumed_round_trip_cost_pct": {
      "type": "number"
    }
  }
}
derivatives.funding_apr_matrix annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
dex.liquidity_slippage
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to calculate expected DEX price slippage, pool liquidity depth, and optimal routing before executing an on-chain token swap. GeckoTerminal-backed pool analytics with constant-product slippage estimation for the requested trade_size_usd, plus a slippage_tiers array with the same estimate at fixed $1,000/$5,000/$10,000 sizes so an agent can gauge depth at a glance without extra calls. When called with token_address, also returns direct_stablecoin_pool_exists and, when the selected pool isn't USD-quoted, alternate_direct_pool - a different pool for the same token that is, so you know before swapping whether a multi-hop route is actually required or whether a direct pool exists elsewhere. Do not use for centralized exchange (CEX) orderbooks or contract risk analysis. Paid in USDC on Base.

dex.liquidity_slippage input schema
{
  "type": "object",
  "required": [
    "trade_size_usd"
  ],
  "properties": {
    "network": {
      "type": "string",
      "description": "GeckoTerminal network id, e.g. base, eth. Defaults to base."
    },
    "pool_address": {
      "type": "string",
      "description": "Specific DEX pool contract address (optional if token_address is given)."
    },
    "token_address": {
      "type": "string",
      "description": "Token contract address - the most liquid pool is auto-selected (optional if pool_address is given)."
    },
    "trade_size_usd": {
      "type": "number",
      "description": "Hypothetical trade size in USD to estimate slippage for."
    }
  }
}
dex.liquidity_slippage output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "network",
    "trade_size_usd",
    "price_impact_model",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "network": {
      "type": "string"
    },
    "pool_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "pool_address": {
      "type": [
        "string",
        "null"
      ]
    },
    "pool_fee_pct": {
      "type": [
        "number",
        "null"
      ],
      "description": "Swap fee tier of the selected pool, parsed from pool_name. Disclosed for reference only - not subtracted from the slippage estimate."
    },
    "liquidity_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "token_address": {
      "type": [
        "string",
        "null"
      ]
    },
    "slippage_tiers": {
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "object",
        "required": [
          "trade_size_usd"
        ],
        "properties": {
          "warning_level": {
            "type": [
              "string",
              "null"
            ]
          },
          "trade_size_usd": {
            "type": "number"
          },
          "estimated_price_impact_pct": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    },
    "trade_size_usd": {
      "type": "number"
    },
    "volume_24h_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "price_impact_model": {
      "type": "string"
    },
    "quote_token_symbol": {
      "type": [
        "string",
        "null"
      ],
      "description": "Parsed from pool_name (e.g. 'USDC' from 'WETH / USDC 0.05%')."
    },
    "assumed_gas_cost_usd": {
      "type": [
        "number",
        "null"
      ],
      "description": "Flat per-swap gas estimate for this network, not a live gas quote."
    },
    "alternate_direct_pool": {
      "type": [
        "object",
        "null"
      ],
      "properties": {
        "pool_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "pool_address": {
          "type": [
            "string",
            "null"
          ]
        },
        "liquidity_usd": {
          "type": [
            "number",
            "null"
          ]
        },
        "quote_token_symbol": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "description": "Only set when quote_token_is_stablecoin is false/null AND a stablecoin-quoted pool exists elsewhere for this token - lets you re-query with that pool_address instead of assuming a multi-hop route."
    },
    "estimated_slippage_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "quote_token_is_stablecoin": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "If false or null, this pool isn't USD-quoted - an extra hop is needed to reach USD, not accounted for in the slippage estimate."
    },
    "direct_stablecoin_pool_exists": {
      "type": [
        "boolean",
        "null"
      ],
      "description": "Whether ANY pool for this token (not just the one selected above) is quoted directly against a USD stablecoin. Null when pool_address was passed directly (no full pool list was fetched)."
    }
  }
}
dex.liquidity_slippage annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
arb.spread_matrix
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool before executing a cross-venue arbitrage trade to check whether a global reference price (Coinbase spot, CoinGecko fallback - not a specific exchange orderbook) and a DEX pool price diverge enough to be worth trading after an assumed flat gas cost. Returns gross/net spread percentages and an is_profitable boolean - note net_spread_pct does NOT subtract the DEX pool's own swap fee (see pool_fee_pct), CEX trading fees, or slippage, so a spread that clears the threshold before those costs may not clear it after. Do not use for DEX-only liquidity depth checks or contract security. Paid in USDC on Base.

arb.spread_matrix input schema
{
  "type": "object",
  "required": [
    "symbol"
  ],
  "properties": {
    "symbol": {
      "type": "string",
      "description": "Ticker symbol, e.g. SUI, BTC, ETH."
    },
    "network": {
      "type": "string",
      "description": "GeckoTerminal network id, e.g. base, eth. Defaults to base."
    },
    "pool_address": {
      "type": "string",
      "description": "Specific DEX pool contract address (optional if token_address is given)."
    },
    "token_address": {
      "type": "string",
      "description": "Token contract address - the most liquid pool is auto-selected (optional if pool_address is given)."
    },
    "trade_size_usd": {
      "type": "number",
      "description": "Hypothetical trade size in USD. Defaults to 1000."
    },
    "min_spread_threshold_pct": {
      "type": "number",
      "description": "Net spread threshold (%) above which is_profitable is true. Defaults to 0.8."
    }
  }
}
arb.spread_matrix output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "symbol",
    "network",
    "status_message",
    "is_profitable",
    "trade_size_usd",
    "assumed_gas_cost_usd",
    "min_spread_threshold_pct",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "symbol": {
      "type": "string"
    },
    "network": {
      "type": "string"
    },
    "direction": {
      "type": [
        "string",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "pool_address": {
      "type": [
        "string",
        "null"
      ]
    },
    "pool_fee_pct": {
      "type": [
        "number",
        "null"
      ],
      "description": "DEX pool's fee tier (e.g. 0.05 for 0.05%), parsed from the pool name. Informational only - net_spread_pct does not subtract it."
    },
    "cex_price_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "dex_price_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "is_profitable": {
      "type": "boolean"
    },
    "net_spread_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "status_message": {
      "type": "string"
    },
    "trade_size_usd": {
      "type": "number"
    },
    "gross_spread_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "assumed_gas_cost_usd": {
      "type": "number"
    },
    "min_spread_threshold_pct": {
      "type": "number"
    }
  }
}
arb.spread_matrix annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
derivatives.whale_position_audit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to audit a Hyperliquid wallet address you already know: every open perpetual position with side, size, leverage, max_leverage, unrealized PnL, return_on_equity_pct, liquidation price, and distance-to-liquidation percentage (max_leverage and return_on_equity_pct are Hyperliquid's own reported fields, not derived by this tool). This does not discover or rank 'smart money' wallets - Hyperliquid's public API has no leaderboard or large-trader disclosure endpoint, so it only audits an address you supply. risk_flags (HIGH_LEVERAGE, NEAR_LIQUIDATION) come from fixed numeric thresholds only. Do not use for spot price data or any exchange other than Hyperliquid. Paid in USDC on Base.

derivatives.whale_position_audit input schema
{
  "type": "object",
  "required": [
    "address"
  ],
  "properties": {
    "address": {
      "type": "string",
      "description": "Hyperliquid/EVM wallet address to audit (0x...)."
    }
  }
}
derivatives.whale_position_audit output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "wallet_address",
    "open_position_count",
    "positions",
    "risk_flags",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "positions": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "coin",
          "side",
          "size",
          "leverage_type"
        ],
        "properties": {
          "coin": {
            "type": "string"
          },
          "side": {
            "type": "string"
          },
          "size": {
            "type": "number"
          },
          "leverage": {
            "type": [
              "number",
              "null"
            ]
          },
          "mark_price": {
            "type": [
              "number",
              "null"
            ]
          },
          "entry_price": {
            "type": [
              "number",
              "null"
            ]
          },
          "max_leverage": {
            "type": [
              "number",
              "null"
            ],
            "description": "Hyperliquid's own reported leverage ceiling for this asset/account setting - not the leverage actually in use."
          },
          "leverage_type": {
            "type": "string"
          },
          "liquidation_price": {
            "type": [
              "number",
              "null"
            ]
          },
          "position_value_usd": {
            "type": [
              "number",
              "null"
            ]
          },
          "unrealized_pnl_usd": {
            "type": [
              "number",
              "null"
            ]
          },
          "return_on_equity_pct": {
            "type": [
              "number",
              "null"
            ],
            "description": "Hyperliquid's own reported ROE for this position, as a percentage - not derived by this tool."
          },
          "distance_to_liquidation_pct": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    },
    "risk_flags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "wallet_address": {
      "type": "string"
    },
    "margin_usage_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "withdrawable_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "account_value_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "open_position_count": {
      "type": "integer"
    },
    "total_margin_used_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "total_notional_position_usd": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
derivatives.whale_position_audit annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
calendar.macro_dday
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool when an agent plans trading schedules around major US macroeconomic volatility, specifically days remaining until FOMC rate decisions, CPI prints, or NFP jobs reports. Zero-dependency static 2026 macro calendar with 100% uptime and no upstream failure risk. Do not use for real-time market price data or economic forecast consensus figures. No input parameters. Paid in USDC on Base.

calendar.macro_dday input schema
{
  "type": "object",
  "required": [],
  "properties": {}
}
calendar.macro_dday output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "tags",
    "upcoming_events",
    "data_source"
  ],
  "properties": {
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "d_day": {
      "type": [
        "integer",
        "null"
      ]
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "event_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "event_type": {
      "type": [
        "string",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "description": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "impact_level": {
      "type": [
        "string",
        "null"
      ]
    },
    "event_datetime": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "time_remaining": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "days",
            "hours",
            "minutes"
          ],
          "properties": {
            "days": {
              "type": "integer"
            },
            "hours": {
              "type": "integer"
            },
            "minutes": {
              "type": "integer"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "upcoming_events": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "event_name",
          "event_type",
          "event_datetime",
          "impact_level"
        ],
        "properties": {
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "event_name": {
            "type": "string"
          },
          "event_type": {
            "type": "string"
          },
          "impact_level": {
            "type": "string"
          },
          "event_datetime": {
            "type": "object",
            "required": [
              "utc",
              "kst"
            ],
            "properties": {
              "kst": {
                "type": "string"
              },
              "utc": {
                "type": "string"
              }
            }
          }
        }
      }
    }
  }
}
calendar.macro_dday annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.neg_risk_arbitrage
Advertised by the server during the last successful anonymous check.
Advertised read-only

Detect basket arbitrage in a Polymarket neg-risk (mutually-exclusive, multi-outcome) event - a full YES basket across all outcomes always settles to exactly $1, so a basket price away from $1 (after costs) is a near risk-free edge. Also returns buy/sell_basket_capacity_shares, the actual liquidity-bottleneck size executable right now, so this isn't just a top-of-book mirage - note *_capacity_notional_usd still prices that size at top-of-book (optimistic), so use *_capacity_vwap_notional_usd for the realistic fill cost. Also returns oldest_book_snapshot_time, the staleness bottleneck across all legs. Polymarket only. Do not use for binary Yes/No markets (no basket to arbitrage) or for Kalshi (its Data ToS forbids this use). Paid in USDC on Base.

prediction.neg_risk_arbitrage input schema
{
  "type": "object",
  "required": [
    "event_slug"
  ],
  "properties": {
    "event_slug": {
      "type": "string",
      "description": "Polymarket event slug, from the event's URL on polymarket.com."
    },
    "max_slippage_pct": {
      "type": "number",
      "description": "How far past each leg's best price to walk the book when sizing capacity. Defaults to 1.0."
    },
    "min_net_edge_pct": {
      "type": "number",
      "description": "Minimum net edge (%) required to flag arbitrage_viable: true. Defaults to 1.0."
    },
    "assumed_round_trip_cost_pct": {
      "type": "number",
      "description": "Gas + fees + slippage buffer, as a percentage of $1 basket notional. Defaults to 1.5."
    }
  }
}
prediction.neg_risk_arbitrage output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "event_slug",
    "num_outcomes",
    "assumed_round_trip_cost_pct",
    "buy_basket_capacity_shares",
    "sell_basket_capacity_shares",
    "opportunity",
    "arbitrage_viable",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "event_slug": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "opportunity": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "num_outcomes": {
      "type": "integer"
    },
    "basket_ask_sum": {
      "type": [
        "number",
        "null"
      ]
    },
    "basket_bid_sum": {
      "type": [
        "number",
        "null"
      ]
    },
    "arbitrage_viable": {
      "type": "boolean"
    },
    "buy_basket_net_edge_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "sell_basket_net_edge_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "buy_basket_gross_edge_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "oldest_book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ],
      "description": "The oldest of each leg's own order-book snapshot timestamp - the staleness bottleneck across all legs, since the whole basket calculation is only as fresh as its stalest leg. Null if no leg reported a timestamp."
    },
    "buy_basket_capacity_shares": {
      "type": "number"
    },
    "sell_basket_gross_edge_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "assumed_round_trip_cost_pct": {
      "type": "number"
    },
    "sell_basket_capacity_shares": {
      "type": "number"
    },
    "buy_basket_capacity_notional_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "sell_basket_capacity_notional_usd": {
      "type": [
        "number",
        "null"
      ]
    },
    "buy_basket_capacity_vwap_notional_usd": {
      "type": [
        "number",
        "null"
      ],
      "description": "Volume-weighted price of filling buy_basket_capacity_shares by walking the order book depth, instead of pricing it at top-of-book like buy_basket_capacity_notional_usd does - more realistic actual fill cost."
    },
    "sell_basket_capacity_vwap_notional_usd": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
prediction.neg_risk_arbitrage annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.exit_capacity_audit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Walk a single Polymarket outcome's live order book to determine how much of a given position size can actually be filled right now, at what average price, and with how much price impact versus the best quote - a live snapshot, not historical liquidity. Also returns book_snapshot_time (the book's own reported timestamp) and Polymarket's own tick_size/min_order_size for this market (null if the book response didn't include them). Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically - exact slug only, no fuzzy keyword search. Do not use for multi-outcome basket arbitrage detection (use prediction.neg_risk_arbitrage instead). Paid in USDC on Base.

prediction.exit_capacity_audit input schema
{
  "type": "object",
  "required": [
    "position_size_shares"
  ],
  "properties": {
    "side": {
      "type": "string",
      "description": "\"sell\" (default) or \"buy\"."
    },
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    },
    "position_size_shares": {
      "type": "number",
      "description": "Number of outcome shares to sell (or buy). Must be positive."
    }
  }
}
prediction.exit_capacity_audit output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "side",
    "position_size_shares",
    "executable",
    "max_executable_shares",
    "data_source"
  ],
  "properties": {
    "side": {
      "type": "string"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "token_id": {
      "type": "string"
    },
    "tick_size": {
      "type": [
        "number",
        "null"
      ],
      "description": "Polymarket's own reported minimum price increment for this market. Null if the book response didn't include it."
    },
    "best_quote": {
      "type": [
        "number",
        "null"
      ]
    },
    "executable": {
      "type": "boolean"
    },
    "data_source": {
      "type": "string"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "avg_exit_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "min_order_size": {
      "type": [
        "number",
        "null"
      ],
      "description": "Polymarket's own reported minimum order size for this market. Null if the book response didn't include it."
    },
    "price_impact_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ],
      "description": "The order book's own reported snapshot timestamp, so you can judge how fresh this read is."
    },
    "position_size_shares": {
      "type": "number"
    },
    "max_executable_shares": {
      "type": "number"
    }
  }
}
prediction.exit_capacity_audit annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.order_split_guide
Advertised by the server during the last successful anonymous check.
Advertised read-only

Walks a Polymarket outcome's live order book to recommend how many clips to split a large position into, so each clip's own price impact stays at or under max_price_impact_pct_per_slice (default 1.0%). Also returns full_size_price_impact_pct - the baseline impact if filled in one shot right now, for comparison. Single-snapshot calculation - it has no idea whether the book refills between clips in real trading. Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically - exact slug only, no fuzzy keyword search. Paid in USDC on Base.

prediction.order_split_guide input schema
{
  "type": "object",
  "required": [
    "position_size_shares"
  ],
  "properties": {
    "side": {
      "type": "string",
      "description": "\"sell\" (default) or \"buy\"."
    },
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    },
    "position_size_shares": {
      "type": "number",
      "description": "Total number of outcome shares to sell (or buy). Must be positive."
    },
    "max_price_impact_pct_per_slice": {
      "type": "number",
      "description": "Target ceiling on each clip's own price impact, in percent. Defaults to 1.0."
    }
  }
}
prediction.order_split_guide output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "side",
    "position_size_shares",
    "max_price_impact_pct_per_slice",
    "executable_now",
    "max_single_clip_shares",
    "data_source"
  ],
  "properties": {
    "side": {
      "type": "string"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "token_id": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "executable_now": {
      "type": "boolean"
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "position_size_shares": {
      "type": "number"
    },
    "max_single_clip_shares": {
      "type": "number"
    },
    "recommended_slice_count": {
      "type": [
        "integer",
        "null"
      ]
    },
    "full_size_price_impact_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "recommended_slice_size_shares": {
      "type": [
        "number",
        "null"
      ]
    },
    "max_price_impact_pct_per_slice": {
      "type": "number"
    }
  }
}
prediction.order_split_guide annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.bid_ask_spread_pct
Advertised by the server during the last successful anonymous check.
Advertised read-only

Cheap tier - a single Polymarket outcome's live top-of-book bid/ask spread as a percentage of mid_price. Not a liquidity or executability measure (use prediction.exit_capacity_audit/order_split_guide for that). Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically - exact slug only, no fuzzy keyword search. Paid in USDC on Base.

prediction.bid_ask_spread_pct input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    }
  }
}
prediction.bid_ask_spread_pct output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "best_ask": {
      "type": [
        "number",
        "null"
      ]
    },
    "best_bid": {
      "type": [
        "number",
        "null"
      ]
    },
    "token_id": {
      "type": "string"
    },
    "mid_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "spread_abs": {
      "type": [
        "number",
        "null"
      ]
    },
    "spread_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
prediction.bid_ask_spread_pct annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.orderbook_imbalance_ratio
Advertised by the server during the last successful anonymous check.
Advertised read-only

A single Polymarket outcome's bid-side vs ask-side order-book depth ratio, summed within depth_band_pct (default 5.0%) of each side's own best quote. 0.5 = balanced, closer to 1.0 = bid-side depth dominant, closer to 0.0 = ask-side dominant. A descriptive statistic only - not a prediction of price direction. Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically. Paid in USDC on Base.

prediction.orderbook_imbalance_ratio input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    },
    "depth_band_pct": {
      "type": "number",
      "description": "How far into the book, as a percent of each side's own best quote, to sum depth. Defaults to 5.0."
    }
  }
}
prediction.orderbook_imbalance_ratio output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "depth_band_pct",
    "bid_depth_shares",
    "ask_depth_shares",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "best_ask": {
      "type": [
        "number",
        "null"
      ]
    },
    "best_bid": {
      "type": [
        "number",
        "null"
      ]
    },
    "token_id": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "depth_band_pct": {
      "type": "number"
    },
    "imbalance_ratio": {
      "type": [
        "number",
        "null"
      ]
    },
    "ask_depth_shares": {
      "type": "number"
    },
    "bid_depth_shares": {
      "type": "number"
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
prediction.orderbook_imbalance_ratio annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.liquidity_depth_after_haircut
Advertised by the server during the last successful anonymous check.
Advertised read-only

A single Polymarket outcome's executable depth within max_price_impact_pct (default 5.0%) of the best quote, both before and after discounting the top-of-book level's size by haircut_pct (default 10.0%) to model the risk that the very best resting order gets cancelled before you can trade against it. Does not detect or flag actual spoofing (out of scope). Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically. Paid in USDC on Base.

prediction.liquidity_depth_after_haircut input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "side": {
      "type": "string",
      "description": "\"sell\" (default) or \"buy\"."
    },
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "haircut_pct": {
      "type": "number",
      "description": "Percent to discount the top-of-book level's size by, modeling cancellation risk. Defaults to 10.0."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    },
    "max_price_impact_pct": {
      "type": "number",
      "description": "Price-impact bound (percent of best quote) within which depth is summed. Defaults to 5.0."
    }
  }
}
prediction.liquidity_depth_after_haircut output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "side",
    "haircut_pct",
    "max_price_impact_pct",
    "depth_shares_before_haircut",
    "depth_shares_after_haircut",
    "data_source"
  ],
  "properties": {
    "side": {
      "type": "string"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "token_id": {
      "type": "string"
    },
    "best_quote": {
      "type": [
        "number",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "haircut_pct": {
      "type": "number"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "max_price_impact_pct": {
      "type": "number"
    },
    "depth_shares_after_haircut": {
      "type": "number"
    },
    "depth_shares_before_haircut": {
      "type": "number"
    }
  }
}
prediction.liquidity_depth_after_haircut annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.polymarket_fee_estimate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Polymarket's own taker fee (NOT gas, slippage, or AlphaPipeline's own charge) for a hypothetical fill of `shares` at `price`, using the official bell-curve formula shares * fee_rate * price * (1 - price). fee_rate is read live from Polymarket's own GET /fee-rate for the exact token_id - never hardcoded, since per-category rates have changed before. Makers pay 0 across every category - this is the taker fee only. Omit price to use the live best book quote for side. Accepts either a raw token_id or a market_slug (+ outcome) to resolve it automatically. Paid in USDC on Base.

prediction.polymarket_fee_estimate input schema
{
  "type": "object",
  "required": [
    "shares"
  ],
  "properties": {
    "side": {
      "type": "string",
      "description": "\"sell\" (default) or \"buy\" - which side of the book to read price from when price is omitted."
    },
    "price": {
      "type": "number",
      "description": "Hypothetical fill price (0-1 exclusive). Omit to use the live best book quote for side."
    },
    "shares": {
      "type": "number",
      "description": "Hypothetical fill size, in shares. Must be > 0."
    },
    "outcome": {
      "type": "string",
      "description": "\"yes\" (default) or \"no\" - which side to resolve when using market_slug."
    },
    "token_id": {
      "type": "string",
      "description": "The outcome's CLOB token_id / asset_id, if already known."
    },
    "market_slug": {
      "type": "string",
      "description": "Exact Polymarket market slug, used to resolve token_id automatically."
    }
  }
}
prediction.polymarket_fee_estimate output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "token_id",
    "shares",
    "price",
    "price_source",
    "base_fee_bp",
    "fee_rate",
    "fee_usd",
    "data_source"
  ],
  "properties": {
    "price": {
      "type": "number"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "shares": {
      "type": "number"
    },
    "fee_usd": {
      "type": "number"
    },
    "fee_rate": {
      "type": "number"
    },
    "token_id": {
      "type": "string"
    },
    "base_fee_bp": {
      "type": "number"
    },
    "data_source": {
      "type": "string"
    },
    "market_slug": {
      "type": [
        "string",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "price_source": {
      "type": "string"
    },
    "book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
prediction.polymarket_fee_estimate annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.polymarket_mispricing
Advertised by the server during the last successful anonymous check.
Advertised read-only

Monotonicity check (higher strike must not be priced above a lower strike) across a set of Polymarket markets that YOU have already confirmed share the same underlying asset and expiry/resolution date. Does NOT verify or infer that settlement-condition equivalence itself - Polymarket's API has no reliable field for it; passing unrelated markets produces a meaningless or false arbitrage signal. Accepts token_ids or market_slugs (+ optional outcomes, default all 'yes'), same length/order as strikes. Not investment advice. Paid in USDC on Base.

prediction.polymarket_mispricing input schema
{
  "type": "object",
  "required": [
    "strikes"
  ],
  "properties": {
    "strikes": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Strike for each rung, same order as token_ids/market_slugs. At least 2 required."
    },
    "outcomes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "\"yes\"/\"no\" per rung when using market_slugs (default: all \"yes\")."
    },
    "token_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "CLOB token_id per rung, if already known. Mutually exclusive with market_slugs."
    },
    "market_slugs": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Polymarket market slug per rung, used to resolve token_ids automatically."
    }
  }
}
prediction.polymarket_mispricing output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "rungs_checked",
    "rungs_skipped_empty_book",
    "violation_count",
    "violations",
    "data_source",
    "notice"
  ],
  "properties": {
    "notice": {
      "type": "string"
    },
    "violations": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "lower_strike",
          "lower_token_id",
          "lower_strike_yes_price",
          "higher_strike",
          "higher_token_id",
          "higher_strike_yes_price",
          "violation_bp",
          "max_riskless_profit_per_usd"
        ],
        "properties": {
          "lower_strike": {
            "type": "number"
          },
          "violation_bp": {
            "type": "number"
          },
          "higher_strike": {
            "type": "number"
          },
          "lower_token_id": {
            "type": "string"
          },
          "higher_token_id": {
            "type": "string"
          },
          "lower_strike_yes_price": {
            "type": "number"
          },
          "higher_strike_yes_price": {
            "type": "number"
          },
          "max_riskless_profit_per_usd": {
            "type": "number"
          }
        }
      }
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "rungs_checked": {
      "type": "integer"
    },
    "violation_count": {
      "type": "integer"
    },
    "rungs_skipped_empty_book": {
      "type": "integer"
    },
    "oldest_book_snapshot_time": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "utc",
            "kst"
          ],
          "properties": {
            "kst": {
              "type": "string"
            },
            "utc": {
              "type": "string"
            }
          }
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
prediction.polymarket_mispricing annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.hip4_snapshot
Advertised by the server during the last successful anonymous check.
Advertised read-only

Real-time probability snapshot of Hyperliquid's HIP-4 outcome (prediction) markets - crypto price binaries, sports game winners, tournament winners, Fed rate decisions, and any other market type Hyperliquid adds, all in one call. No curated market list - every field under 'fields' on each row is parsed verbatim from Hyperliquid's own description string, so new HIP-4 market types appear automatically. standalone_markets covers two-sided markets (most crypto/sports games); grouped_questions covers mutually-exclusive multi-outcome groups (e.g. a league winner) with a fallback price for 'none of the above'. Optional template/underlying filters narrow the result. Do not use for Polymarket data (use prediction.neg_risk_arbitrage/exit_capacity_audit instead). Paid in USDC on Base.

prediction.hip4_snapshot input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "limit": {
      "type": "integer",
      "description": "Max rows per list (standalone_markets / grouped_questions each). Defaults to 100, max 500."
    },
    "template": {
      "type": "string",
      "description": "Optional substring filter on the market's template name (e.g. 'sportsContestWinner', 'priceBinary')."
    },
    "underlying": {
      "type": "string",
      "description": "Optional asset symbol filter for crypto markets (e.g. 'BTC', 'ETH', 'SOL', 'HYPE')."
    }
  }
}
prediction.hip4_snapshot output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "standalone_count",
    "grouped_question_count",
    "standalone_markets",
    "grouped_questions",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "template_filter": {
      "type": [
        "string",
        "null"
      ]
    },
    "standalone_count": {
      "type": "integer"
    },
    "grouped_questions": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "question_id",
          "template",
          "fields",
          "outcomes"
        ],
        "properties": {
          "fields": {
            "type": "object",
            "additionalProperties": {
              "type": "string"
            }
          },
          "fallback": {
            "anyOf": [
              {
                "type": "object",
                "required": [
                  "outcome_id",
                  "label"
                ],
                "properties": {
                  "label": {
                    "type": "string"
                  },
                  "price": {
                    "type": [
                      "number",
                      "null"
                    ]
                  },
                  "outcome_id": {
                    "type": "integer"
                  }
                }
              },
              {
                "type": "null"
              }
            ],
            "description": "The residual 'none of the named outcomes' price."
          },
          "outcomes": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "outcome_id",
                "label"
              ],
              "properties": {
                "label": {
                  "type": "string"
                },
                "price": {
                  "type": [
                    "number",
                    "null"
                  ]
                },
                "outcome_id": {
                  "type": "integer"
                }
              }
            }
          },
          "template": {
            "type": "string"
          },
          "question_id": {
            "type": "integer"
          }
        }
      }
    },
    "underlying_filter": {
      "type": [
        "string",
        "null"
      ]
    },
    "standalone_markets": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "outcome_id",
          "template",
          "fields",
          "sides"
        ],
        "properties": {
          "sides": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "name"
              ],
              "properties": {
                "name": {
                  "type": "string"
                },
                "price": {
                  "type": [
                    "number",
                    "null"
                  ]
                }
              }
            }
          },
          "fields": {
            "type": "object",
            "additionalProperties": {
              "type": "string"
            }
          },
          "template": {
            "type": "string"
          },
          "outcome_id": {
            "type": "integer"
          }
        }
      }
    },
    "grouped_question_count": {
      "type": "integer"
    }
  }
}
prediction.hip4_snapshot annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.hip4_price_ladder
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to see one underlying's Hyperliquid HIP-4 'above $X' price-binary markets laid out as a strike-sorted ladder, each rung with its live Yes probability - e.g. to read the market's implied BTC price distribution at a glance. Reuses the same cached data as prediction.hip4_snapshot - no new upstream call. No volume field (Hyperliquid doesn't expose per-outcome volume for HIP-4). Do not use for mutually-exclusive multi-outcome groups (use prediction.hip4_snapshot's grouped_questions instead) or for Polymarket data. Paid in USDC on Base.

prediction.hip4_price_ladder input schema
{
  "type": "object",
  "required": [
    "underlying"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "description": "Max rungs returned. Defaults to 100, max 500."
    },
    "underlying": {
      "type": "string",
      "description": "Asset symbol for crypto price-binary markets (e.g. 'BTC', 'ETH', 'SOL', 'HYPE')."
    }
  }
}
prediction.hip4_price_ladder output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "underlying",
    "rung_count",
    "skipped_unparsable_count",
    "rungs",
    "data_source"
  ],
  "properties": {
    "rungs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "outcome_id",
          "strike"
        ],
        "properties": {
          "expiry": {
            "type": [
              "string",
              "null"
            ]
          },
          "period": {
            "type": [
              "string",
              "null"
            ]
          },
          "strike": {
            "type": "number"
          },
          "yes_price": {
            "type": [
              "number",
              "null"
            ]
          },
          "outcome_id": {
            "type": "integer"
          }
        }
      }
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "rung_count": {
      "type": "integer"
    },
    "underlying": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "skipped_unparsable_count": {
      "type": "integer"
    }
  }
}
prediction.hip4_price_ladder annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.hip4_price
Advertised by the server during the last successful anonymous check.
Advertised read-only

Cheapest-tier thin wrapper around prediction.hip4_price_ladder - use this when you only need one strike's Yes probability, not the full ladder. Returns the single rung closest to the requested strike - check matched_strike against your requested strike before relying on yes_price; a large gap means no rung exists near your target (use hip4_price_ladder to see what's actually available). Paid in USDC on Base.

prediction.hip4_price input schema
{
  "type": "object",
  "required": [
    "underlying",
    "strike"
  ],
  "properties": {
    "strike": {
      "type": "number",
      "description": "Target price to look up - the closest available rung is returned."
    },
    "underlying": {
      "type": "string",
      "description": "Asset symbol for crypto price-binary markets (e.g. 'BTC', 'ETH', 'SOL', 'HYPE')."
    }
  }
}
prediction.hip4_price output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "underlying",
    "requested_strike",
    "data_source"
  ],
  "properties": {
    "expiry": {
      "type": [
        "string",
        "null"
      ]
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "yes_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "underlying": {
      "type": "string"
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "matched_strike": {
      "type": [
        "number",
        "null"
      ],
      "description": "The closest available rung's strike - NOT guaranteed to equal requested_strike."
    },
    "requested_strike": {
      "type": "number"
    }
  }
}
prediction.hip4_price annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
prediction.hip4_mispricing
Advertised by the server during the last successful anonymous check.
Advertised read-only

Finds monotonicity violations among Hyperliquid HIP-4 'above $X' price-binary markets: within the same underlying/expiry/period, a higher strike's Yes price should never exceed a lower strike's - any reversal is a logical inconsistency, quantified as violation_bp and a textbook max_riskless_profit_per_usd (before fees/slippage/execution risk - not investment advice). Reuses prediction.hip4_price_ladder's cache - no new upstream call. Only rungs sharing the exact same (expiry, period) are ever compared. Paid in USDC on Base.

prediction.hip4_mispricing input schema
{
  "type": "object",
  "required": [
    "underlying"
  ],
  "properties": {
    "underlying": {
      "type": "string",
      "description": "Asset symbol for crypto price-binary markets (e.g. 'BTC', 'ETH', 'SOL', 'HYPE')."
    }
  }
}
prediction.hip4_mispricing output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "underlying",
    "expiry_groups_checked",
    "total_rungs_checked",
    "violation_count",
    "violations",
    "settlement_condition_note",
    "data_source"
  ],
  "properties": {
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "underlying": {
      "type": "string"
    },
    "violations": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "lower_strike",
          "lower_strike_yes_price",
          "higher_strike",
          "higher_strike_yes_price",
          "violation_bp",
          "max_riskless_profit_per_usd"
        ],
        "properties": {
          "expiry": {
            "type": [
              "string",
              "null"
            ]
          },
          "period": {
            "type": [
              "string",
              "null"
            ]
          },
          "lower_strike": {
            "type": "number"
          },
          "violation_bp": {
            "type": "number"
          },
          "higher_strike": {
            "type": "number"
          },
          "lower_strike_yes_price": {
            "type": "number"
          },
          "higher_strike_yes_price": {
            "type": "number"
          },
          "max_riskless_profit_per_usd": {
            "type": "number"
          }
        }
      }
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "violation_count": {
      "type": "integer"
    },
    "total_rungs_checked": {
      "type": "integer"
    },
    "expiry_groups_checked": {
      "type": "integer"
    },
    "settlement_condition_note": {
      "type": "string"
    }
  }
}
prediction.hip4_mispricing annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
market.cycle_compare
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to see BTC/ETH's own price position vs the same day-offset in the 2016 and 2020 halving cycles, plus today's real BTC dominance. This is NOT a historical dominance comparison (no free data source exists for that - see the response's notice field). Derived from a cache refreshed once daily, so prices can be up to ~24h stale. No input params. Paid in USDC on Base.

market.cycle_compare input schema
{
  "type": "object",
  "required": [],
  "properties": {}
}
market.cycle_compare output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "current_cycle_halving_date",
    "days_since_halving",
    "btc",
    "eth",
    "data_source"
  ],
  "properties": {
    "btc": {
      "type": "object",
      "required": [
        "data_ok"
      ],
      "properties": {
        "data_ok": {
          "type": "boolean"
        },
        "price_usd_today": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_vs_2016_cycle_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_vs_2020_cycle_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "price_usd_on_current_halving": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct_2016_cycle_same_day": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct_2020_cycle_same_day": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    },
    "eth": {
      "type": "object",
      "required": [
        "data_ok"
      ],
      "properties": {
        "data_ok": {
          "type": "boolean"
        },
        "price_usd_today": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_vs_2016_cycle_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_vs_2020_cycle_pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "price_usd_on_current_halving": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct_2016_cycle_same_day": {
          "type": [
            "number",
            "null"
          ]
        },
        "return_since_halving_pct_2020_cycle_same_day": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "dxy_level": {
      "type": [
        "number",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "us10y_yield_pct": {
      "type": [
        "number",
        "null"
      ]
    },
    "days_since_halving": {
      "type": "integer"
    },
    "cache_generated_at_utc": {
      "type": [
        "string",
        "null"
      ]
    },
    "btc_dominance_pct_today": {
      "type": [
        "number",
        "null"
      ]
    },
    "current_cycle_halving_date": {
      "type": "string"
    }
  }
}
market.cycle_compare annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
market.oracle_gap
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to check whether a protocol pricing off Hyperliquid's raw mid (instead of mark/oracle) is currently exposed to a mid-price swing - the exact failure mode behind the 2026-10-10 Papertrade incident on HyperEVM. elevated is a fixed-threshold flag (abs(mid_oracle_gap_bp) >= alert_threshold_bp), not a manipulation determination. Single snapshot, no trade-flow/volume data (Hyperliquid doesn't expose it). Paid in USDC on Base.

market.oracle_gap input schema
{
  "type": "object",
  "required": [
    "coin"
  ],
  "properties": {
    "coin": {
      "type": "string",
      "description": "Hyperliquid perpetual ticker, e.g. ETH or BTC."
    }
  }
}
market.oracle_gap output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "coin",
    "elevated",
    "alert_threshold_bp",
    "data_source"
  ],
  "properties": {
    "coin": {
      "type": "string"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "elevated": {
      "type": "boolean",
      "description": "True when abs(mid_oracle_gap_bp) >= alert_threshold_bp. A fixed-threshold boolean, not a manipulation determination - see notice."
    },
    "mid_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "mark_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "oracle_price": {
      "type": [
        "number",
        "null"
      ]
    },
    "mid_oracle_gap_bp": {
      "type": [
        "number",
        "null"
      ],
      "description": "(mid_price - oracle_price) / oracle_price * 10000, in basis points."
    },
    "alert_threshold_bp": {
      "type": "number"
    },
    "mark_oracle_gap_bp": {
      "type": [
        "number",
        "null"
      ],
      "description": "(mark_price - oracle_price) / oracle_price * 10000, in basis points."
    }
  }
}
market.oracle_gap annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
market.oracle_gap_bp
Advertised by the server during the last successful anonymous check.
Advertised read-only

Cheapest-tier thin wrapper around market.oracle_gap - use this when you only need mid_oracle_gap_bp/mark_oracle_gap_bp and the elevated flag, not the absolute mid/mark/oracle prices. Same Hyperliquid data. Paid in USDC on Base.

market.oracle_gap_bp input schema
{
  "type": "object",
  "required": [
    "coin"
  ],
  "properties": {
    "coin": {
      "type": "string",
      "description": "Hyperliquid perpetual ticker, e.g. ETH or BTC."
    }
  }
}
market.oracle_gap_bp output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "coin",
    "elevated",
    "alert_threshold_bp",
    "data_source"
  ],
  "properties": {
    "coin": {
      "type": "string"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "elevated": {
      "type": "boolean",
      "description": "True when abs(mid_oracle_gap_bp) >= alert_threshold_bp. A fixed-threshold boolean, not a manipulation determination."
    },
    "data_source": {
      "type": "string"
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "mid_oracle_gap_bp": {
      "type": [
        "number",
        "null"
      ]
    },
    "alert_threshold_bp": {
      "type": "number"
    },
    "mark_oracle_gap_bp": {
      "type": [
        "number",
        "null"
      ]
    }
  }
}
market.oracle_gap_bp annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}
unlocks.dump_risk
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this tool to evaluate token unlock/vesting supply overhang risk before taking mid-to-long term positions - returns tokens whose currently-locked or unlock-eligible supply exceeds a materiality threshold, each with a computed risk_level (LOW/MEDIUM/HIGH). Default data source (on-chain Sablier vesting, the current configuration - no DropsTab key set) does NOT classify VC/team vs. other holders (is_insider_vc_team is always null) and does NOT provide exact unlock timing (days_until_unlock is always null, timing_precision='pending_schema_verification') - it only reports the currently-locked supply ratio. It does report vesting_deposit_amount/vesting_withdrawn_amount (Sablier's own depositAmount/withdrawnAmount, aggregated across streams) and vesting_progress_pct (withdrawn/deposit * 100), showing how far along the vesting schedule already is. Treat a null value as 'unknown', never as 'no risk'. Always check the response's coverage_notice field. Do not use for intra-day slippage or real-time transaction simulation. Paid in USDC on Base (free while DUMP_RISK_ENABLED=false).

unlocks.dump_risk input schema
{
  "type": "object",
  "required": [],
  "properties": {}
}
unlocks.dump_risk output schema
{
  "type": "object",
  "required": [
    "generated_at",
    "supply_pct_threshold",
    "protocols_scanned",
    "count",
    "unlocks"
  ],
  "properties": {
    "count": {
      "type": "integer"
    },
    "notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "unlocks": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "token",
          "unlock_supply_pct",
          "category",
          "risk_level"
        ],
        "properties": {
          "token": {
            "type": "string"
          },
          "category": {
            "type": "string"
          },
          "risk_level": {
            "type": "string"
          },
          "data_source": {
            "type": [
              "string",
              "null"
            ]
          },
          "unlock_amount": {
            "type": [
              "number",
              "null"
            ]
          },
          "unlock_date_utc": {
            "type": [
              "string",
              "null"
            ]
          },
          "onchain_contract": {
            "type": [
              "string",
              "null"
            ]
          },
          "timing_precision": {
            "type": [
              "string",
              "null"
            ]
          },
          "days_until_unlock": {
            "type": [
              "number",
              "null"
            ]
          },
          "unlock_supply_pct": {
            "type": "number"
          },
          "volume_impact_pct": {
            "type": [
              "number",
              "null"
            ]
          },
          "is_insider_vc_team": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "vesting_progress_pct": {
            "type": [
              "number",
              "null"
            ],
            "description": "On-chain-only field: vesting_withdrawn_amount / vesting_deposit_amount * 100 - how far along the vesting schedule already is. Null on the DropsTab path and when deposit data wasn't available."
          },
          "vesting_deposit_amount": {
            "type": [
              "number",
              "null"
            ],
            "description": "On-chain-only field (Sablier's depositAmount, aggregated across streams). Total amount originally scheduled to vest. Null on the DropsTab path and when unavailable."
          },
          "vesting_withdrawn_amount": {
            "type": [
              "number",
              "null"
            ],
            "description": "On-chain-only field (Sablier's withdrawnAmount, aggregated across streams). Amount already claimed/withdrawn so far. Null on the DropsTab path and when unavailable."
          }
        }
      }
    },
    "data_source": {
      "type": [
        "string",
        "null"
      ]
    },
    "window_days": {
      "type": [
        "integer",
        "null"
      ]
    },
    "generated_at": {
      "type": "object",
      "required": [
        "utc",
        "kst"
      ],
      "properties": {
        "kst": {
          "type": "string"
        },
        "utc": {
          "type": "string"
        }
      }
    },
    "coverage_notice": {
      "type": [
        "string",
        "null"
      ]
    },
    "protocols_scanned": {
      "type": "integer"
    },
    "supply_pct_threshold": {
      "type": "number"
    }
  }
}
unlocks.dump_risk annotations
{
  "readOnlyHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
992 ms
95th percentile latency
992 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 992 ms · metadata changed · 30 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http alphapipeline-mcp https://alphapipeline-eu.onrender.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add alphapipeline-mcp --url https://alphapipeline-eu.onrender.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable alphapipeline-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "alphapipeline-mcp": {
      "url": "https://alphapipeline-eu.onrender.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "alphapipeline-mcp": {
      "type": "streamableHttp",
      "url": "https://alphapipeline-eu.onrender.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start alphapipeline-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "alphapipeline-mcp": {
      "type": "http",
      "url": "https://alphapipeline-eu.onrender.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http alphapipeline-mcp https://alphapipeline-eu.onrender.com/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://alphapipeline-eu.onrender.com/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "alphapipeline-mcp": {
      "serverUrl": "https://alphapipeline-eu.onrender.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like AlphaPipeline MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.