polymarket-mcp-server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@polymarket-mcp-serverfind arbitrage opportunities between Polymarket and Kalshi"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Polymarket MCP Server ๐ฎโก
The premier Model Context Protocol (MCP) server for prediction markets. Connect Claude Desktop, Cursor IDE, Windsurf, and autonomous quant agents directly to live Level 2 orderbook depth, cross-venue arbitrage detection, quadratic fee solvers, and whale block trade orderflow across Polymarket, Kalshi, Limitless, PredictIt, ForecastEx, Smarkets, and Drift BET.
๐ Table of Contents
Related MCP server: telekash-mcp-server
๐ Overview
polymarket-mcp-server implements a lightweight, ultra-low latency JSON-RPC 2.0 stdio server compliant with the Model Context Protocol (MCP) 2024-11-05 specification.
Designed specifically for AI-driven quantitative analysis, market-making research, and prediction market trading, this server equips AI assistants with 5 institutional-grade financial tools:
Level 2 Normalized Depth: Real-time bid/ask ladders, mid-prices, basis point spreads, and Order Book Imbalance (OBI).
Cross-Venue Matched Arbitrage: Live scanner identifying pricing discrepancies between Polymarket and regulated exchanges like Kalshi or ForecastEx, complete with gross edge, net ROI, and annualized yields.
Exact Quadratic Fee Solver: Computes Kalshi CFTC Rule 40.2 quadratic taker fees (
ceil(0.07 * C * P * (1-P))) and solves closed-form quadratic equations (0.07*P^2 - 1.07*P + K >= 0) for guaranteed positive-EV counterpart pricing.Institutional Whale Orderflow: Live tape monitoring large block fills (> $5,000, > $50,000, > $100,000) with on-chain wallet addresses and Polygon transaction hashes.
Multi-Venue Market Search: Universal catalog query across 7 venues simultaneously.
๐ฏ Target Capabilities
Polymarket MCP Server: Native integration for decentralized Polygon CLOB orderbooks.
Model Context Protocol: Fully compliant MCP tool provider supporting
initialize,ping,tools/list, andtools/call.Claude Prediction Market: Empowers Claude 3.5 Sonnet and Claude 3.7 with real-time financial mathematics.
Cursor Polymarket Tool: Enables Cursor IDE developers to query live orderbooks and backtest strategies in chat.
Kalshi MCP: CFTC-regulated binary contract fee modeling and cross-venue pairing.
๐ Architecture
flowchart TD
subgraph Clients["AI Clients & IDEs"]
CD["Claude Desktop"]
CR["Cursor IDE"]
WS["Windsurf / Agents"]
end
subgraph Server["polymarket-mcp-server"]
STDIO["JSON-RPC 2.0 stdio Transport<br/>(Line-delimited & Content-Length)"]
DISP["Tool Registry & Dispatcher"]
MATH["Quadratic Fee & Breakeven Math Engine"]
CLIENT["NaxosData API Client & Fallback Provider"]
end
subgraph Venues["Prediction Venues (7 Covered)"]
POLY["Polymarket (Polygon L2 CLOB)"]
KALSHI["Kalshi (CFTC Binary)"]
FCX["ForecastEx (IBKR)"]
LIMITLESS["Limitless Exchange"]
PREDICTIT["PredictIt"]
SMARKETS["Smarkets"]
DRIFT["Drift BET (Solana)"]
end
CD <-->|stdio JSON-RPC| STDIO
CR <-->|stdio JSON-RPC| STDIO
WS <-->|stdio JSON-RPC| STDIO
STDIO --> DISP
DISP --> MATH
DISP --> CLIENT
CLIENT -->|NaxosData Gateway / Direct CLOB| Venuesโก 60-Second Setup
1. Claude Desktop Setup
Open your Claude Desktop configuration file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
Add the polymarket server to mcpServers:
{
"mcpServers": {
"polymarket": {
"command": "npx",
"args": ["-y", "polymarket-mcp-server"],
"env": {
"NAXOS_API_KEY": "your_naxos_api_key_here"
}
}
}
}Note:
NAXOS_API_KEYis optional for initial setup. When omitted, the server operates in public fallback mode. For live sub-second orderbooks and historical archives, provide a key from naxosdata.com.
Restart Claude Desktop, and you will see the ๐จ tool icon active!
2. Cursor IDE Setup
In your project workspace, create or edit .cursor/mcp.json:
{
"mcpServers": {
"polymarket": {
"command": "npx",
"args": ["-y", "polymarket-mcp-server"],
"env": {
"NAXOS_API_KEY": "your_naxos_api_key_here"
}
}
}
}Alternatively, open Cursor Settings โ Features โ MCP โ Add New MCP Server:
Name:
polymarketType:
commandCommand:
npx -y polymarket-mcp-server
3. Windsurf & Custom Agents
In ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"polymarket": {
"command": "npx",
"args": ["-y", "polymarket-mcp-server"]
}
}
}๐ MCP Tools Reference
1. get_market_orderbook
Retrieves normalized Level 2 orderbook depth for any contract across 7 venues. Returns bids, asks, best bid/ask, mid-price, spread in basis points, and top-5 Order Book Imbalance (OBI).
Parameters:
Parameter | Type | Required | Default | Description |
|
| Yes | โ | Market identifier, token condition ID, or venue slug |
|
| No |
|
|
|
| No |
| Number of bid/ask ladder rungs to fetch (1 - 50) |
Example Call:
{
"name": "get_market_orderbook",
"arguments": {
"market_id": "FED-DEC26-CUT",
"venue": "KALSHI",
"depth": 3
}
}Returns:
{
"venue": "KALSHI",
"market_id": "FED-DEC26-CUT",
"timestamp_ms": 1793558701534,
"bids": [[0.52, 10107], [0.51, 15214], [0.50, 5321]],
"asks": [[0.54, 6714], [0.55, 15821], [0.56, 8928]],
"best_bid": 0.52,
"best_ask": 0.54,
"mid_price": 0.53,
"spread_bps": 377.36,
"obi_top5": -0.013,
"top5_liquidity_usd": 32916,
"microstructure": {
"vwap_divergence_cents": 0.03,
"wire_lag_ms": 18,
"estimated_taker_fee_bps": 175
}
}2. scan_arbitrage_opportunities
Scans cross-venue matched prediction contract pairs (e.g., Polymarket YES vs Kalshi NO) where mutually exclusive outcomes are mispriced, guaranteeing a risk-free payout after fees.
Parameters:
Parameter | Type | Required | Default | Description |
|
| No |
| Filter: |
|
| No |
| Minimum net ROI percentage after exchange taker fees and gas |
|
| No |
| Oracle risk filter: |
|
| No |
| Max pairs to return (1 - 50) |
Example Call:
{
"name": "scan_arbitrage_opportunities",
"arguments": {
"category": "ECONOMICS",
"min_net_roi_pct": 2.0
}
}3. calculate_kalshi_fees
Computes the CFTC-cleared Kalshi quadratic taker fee and solves the closed-form quadratic root solver to calculate the maximum price you can pay for a counterpart leg while achieving target net ROI.
$$\text{Kalshi Taker Fee} = \lceil 0.07 \cdot C \cdot P \cdot (1 - P) \rceil$$
$$0.07 \cdot P_{\text{no}}^2 - 1.07 \cdot P_{\text{no}} + K \ge 0 \quad \text{where } K = \frac{1}{1 + \frac{\text{ROI}}{100}} - P_{\text{poly}} - \text{Gas}$$
Parameters:
Parameter | Type | Required | Default | Description |
|
| No |
| Number of contracts to trade |
|
| No | โ | Kalshi contract price [0.01 - 0.99] for direct fee calculation |
|
| No | โ | Primary leg price (e.g. Polymarket YES at 0.46) to solve breakeven |
|
| No |
| Target net ROI percentage after all taker fees & gas |
Example Call:
{
"name": "calculate_kalshi_fees",
"arguments": {
"contracts": 100,
"price": 0.52,
"primary_price": 0.46,
"target_roi_pct": 2.5
}
}Returns:
{
"contracts": 100,
"price": 0.52,
"calculated_fee_usd": 1.75,
"fee_per_contract_cents": 1.75,
"quadratic_solution": {
"primaryPrice": 0.46,
"targetRoiPct": 2.5,
"contracts": 100,
"primaryFeeCents": 0.008,
"maxCounterpartPrice": 0.498,
"maxCounterpartCents": 49.8,
"counterpartFeeCents": 1.75,
"totalCostCents": 97.56,
"netMarginCents": 2.44,
"isProfitable": true
}
}4. get_whale_trades
Monitors institutional orderflow and block trades with verified on-chain Polygon wallet addresses, transaction hashes, and trade sizes.
Parameters:
Parameter | Type | Required | Default | Description |
|
| No |
|
|
|
| No | โ | Filter by specific market identifier or slug |
|
| No |
| Minimum trade notional size in USD |
|
| No |
| Max trades to return |
5. search_prediction_markets
Universal search engine indexing active contracts across all 7 prediction venues with 24-hour volume, liquidity, and oracle specifications.
Parameters:
Parameter | Type | Required | Default | Description |
|
| Yes | โ | Search term (e.g., |
|
| No |
| Venue filter or |
|
| No | โ | Filter by category ( |
|
| No |
|
|
|
| No |
| Max markets to return |
๐ฌ Real-World LLM Prompts
Once configured in Claude Desktop or Cursor, try asking:
"Search for active prediction markets related to the Federal Reserve December 2026 interest rate decision across all venues.""Scan cross-venue arbitrage pairs in the ECONOMICS category with a minimum net ROI of 2%. Show me the exact execution breakdown.""If Polymarket YES for the Fed rate cut is trading at $0.46, what is the maximum price I can pay on Kalshi NO for 100 contracts to lock in at least 2.5% net ROI after Kalshi's quadratic taker fee?""Show me recent whale block trades over $25,000 on Polymarket and give me the wallet addresses and transaction hashes.""Fetch the Level 2 orderbook for FED-DEC26-CUT on Kalshi and calculate the Order Book Imbalance (OBI)."๐ NaxosData API Gateway Integration
polymarket-mcp-server integrates seamlessly with NaxosData, the leading L2 historical archive and real-time streaming feed provider for prediction markets.
To connect your server to institutional endpoints:
Obtain an API key from naxosdata.com.
Set the environment variable:
export NAXOS_API_KEY="nx_live_your_api_key_here"Or configure it in your
claude_desktop_config.json/.cursor/mcp.json.
Supported key prefixes: nx_live_..., nx_pro_..., nx_inst_..., nx_free_....
๐ป CLI Utilities & Testing
You can inspect and execute MCP tools directly from the terminal without launching an MCP client:
# Print help and usage
npx polymarket-mcp-server --help
# List all available tool schemas
npx polymarket-mcp-server --tools
# Test direct execution of a tool
npx polymarket-mcp-server --test-call calculate_kalshi_fees '{"contracts":100,"price":0.52,"primary_price":0.46,"target_roi_pct":2.5}'
# Test market search
npx polymarket-mcp-server --test-call search_prediction_markets '{"query":"Trump","limit":3}'
# Test orderbook snapshot
npx polymarket-mcp-server --test-call get_market_orderbook '{"market_id":"FED-DEC26-CUT","venue":"KALSHI","depth":3}'๐งช Development & Automated Tests
This repository is built with 100% strict TypeScript and features an automated test suite executed via the native Node.js test runner (node:test).
# Clone the repository
git clone https://github.com/nexosdata/polymarket-mcp-server.git
cd polymarket-mcp-server
# Install dev dependencies
npm install
# Compile TypeScript
npm run build
# Run full test suite (34 test cases across all JSON-RPC methods and math solvers)
npm testTest Coverage Highlights:
Protocol Compliance: JSON-RPC 2.0 handshakes, protocol version
2024-11-05, ping, notifications, error codes (-32700, -32600, -32601, -32602).Transport Framing: Line-delimited JSON and Content-Length framed byte streams.
Quantitative Solvers: Exact boundary tests for Kalshi quadratic fee formulas,
ceilCents()rounding invariants, and closed-form quadratic root solver limits.Tool Validation: Strict schema validation for all 5 MCP endpoints.
๐ License
MIT License. Copyright (c) 2026 NaxosData Contributors & William Gonda.
See the LICENSE file for complete details.
Available Tools
5 toolscalculate_kalshi_feesB
Solve exact quadratic taker fees and maximum counterpart contract prices for Kalshi. Implements CFTC Rule 40.2 quadratic fee formula: ceil(0.07 * C * P * (1-P)), and solves the closed-form quadratic root solver 0.07P_no^2 - 1.07P_no + K >= 0 for guaranteed positive EV cross-venue arbitrage.
| Name | Required | Description | Default |
|---|---|---|---|
| price | No | Contract price on Kalshi [0.01 - 0.99] to calculate exact taker fee | |
| contracts | No | Number of binary outcome contracts (default: 100) | |
| primary_price | No | Primary leg contract price (e.g. Polymarket YES at 0.48) to solve maximum counterpart NO price on Kalshi for guaranteed net ROI | |
| target_roi_pct | No | Target net ROI percentage after all fees and gas (default: 0.0% for breakeven) | |
| counterpart_venue | No | Venue of counterpart leg (default: 'KALSHI') | KALSHI |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It does disclose the exact fee formula and root-solver inequality, which is genuinely useful behavioral context for trusting the output. However, it never says the tool is a pure side-effect-free calculation, never describes the return shape, and never discloses that it operates in two distinct modes (fee lookup vs. counterpart-price solve) โ a real gap for a 5-param tool with zero required fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the purpose before the formula. The formula is dense but earns its place as the tool's defining behavior. Minor cost: the LaTeX-style notation is harder to parse than plain prose would be.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 5 optional parameters, two operating modes, and no output schema, the description should explain which parameter combination triggers which computation and roughly what comes back. It explains the math but not the invocation contract, leaving an agent to guess at mode selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already carries parameter meaning and the baseline is 3. The description reinforces the math behind price/primary_price but adds no interaction semantics โ specifically, it does not say that price+contracts selects fee mode while primary_price+target_roi_pct selects the arbitrage solve mode.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb+resource pair: solving Kalshi quadratic taker fees and maximum counterpart contract prices. The purpose is unambiguous for an agent reading it, though it never contrasts itself with siblings like scan_arbitrage_opportunities, which it plainly complements rather than duplicates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The closing clause 'for guaranteed positive EV cross-venue arbitrage' implies the scenario, but the description never states when to call this versus scan_arbitrage_opportunities, nor does it say what inputs are required for which mode. Usage must be inferred from the parameter names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_market_orderbookB
Retrieve normalized Level 2 orderbook depth for Polymarket, Kalshi, Limitless, PredictIt, ForecastEx, and more. Returns top bids, asks, best bid/ask, mid price, spread in basis points (bps), and orderbook imbalance (OBI).
| Name | Required | Description | Default |
|---|---|---|---|
| depth | No | Number of price ladder levels to retrieve on bids and asks (1 - 50, default 5) | |
| venue | No | Prediction market venue | POLYMARKET |
| market_id | Yes | Market identifier, condition token address, or venue slug (e.g., '0x892a7f...' or 'FED-DEC26-CUT') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden. It signals a read-only retrieval and enumerates return fields (bids, asks, mid, spread bps, OBI), but does not cover error behavior for unknown markets, whether the book can be empty, data freshness/realtime status, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero filler: the first establishes what is retrieved and from where, the second enumerates outputs. It is front-loaded and appropriately sized for the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Since there is no output schema, the description usefully enumerates the return fields, which is the key missing structured information. It falls short only on edge cases like empty or invalid markets and data freshness, which matter for a market-data tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all three parameters (including depth bounds and the venue enum) are already documented in structured fields. The description adds little semantic detail beyond the venue list, which duplicates the enum, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource ('Retrieve normalized Level 2 orderbook depth') and enumerates the supported venues, so an agent immediately knows this is the orderbook data tool. It does not explicitly contrast itself with siblings like search_prediction_markets or scan_arbitrage_opportunities, but the resource is distinct enough to avoid confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this tool versus the alternatives; the sibling set includes market search, arbitrage scanning, and fee calculation, but none are mentioned. The agent must infer that this is for reading depth data rather than discovering markets or opportunities.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_whale_tradesB
Query recent block trades and institutional whale orderflow with on-chain wallet addresses, trade sizes, prices, and transaction hashes across Polymarket, Kalshi, and Limitless.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of trades to return (1 - 50, default 10) | |
| venue | No | Prediction market venue or 'ALL' (default: 'POLYMARKET') | POLYMARKET |
| market_id | No | Optional market identifier or slug to filter trades (e.g. '0x892a...' or 'FED-DEC26') | |
| min_size_usd | No | Minimum trade notional size in USD (default: $5,000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It makes clear this is a read/query operation returning wallet addresses, sizes, prices, and transaction hashes, but it omits rate limits, authentication needs, pagination behavior, and a precise definition of 'recent'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted language. It immediately states the action, resource, returned data, and venue scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description gives enough context for a read query: it names the resource, returned fields, and venue coverage. It is slightly incomplete because 'recent' is undefined and the venue list names only three of the schema's supported venues, but the schema fills those gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the parameter documentation is already handled by the input schema. The description adds useful domain context like block trades and whale orderflow, but does not add parameter-specific meaning beyond what the schema provides for limit, venue, market_id, or min_size_usd.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: query recent block trades and institutional whale orderflow, including the data fields returned and supported venues. The tool is clearly distinct from siblings like orderbook and arbitrage scanners, though it does not explicitly contrast itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies the tool is for whale/block trade queries but gives no explicit when-to-use guidance, no exclusions, and no alternatives among the sibling tools. An agent must infer the use case from the purpose statement alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_arbitrage_opportunitiesA
Find cross-venue matched prediction market arbitrage opportunities (e.g., Polymarket YES vs Kalshi NO, PredictIt vs Polymarket). Calculates exact net ROI, gross edge cents, combined costs, annualized yield, and oracle risk.
| Name | Required | Description | Default |
|---|---|---|---|
| risk | No | Filter by oracle risk rating | ALL |
| limit | No | Maximum number of arbitrage pairs to return (1 - 50, default 10) | |
| category | No | Filter by market category (e.g., 'POLITICS', 'ECONOMICS', 'CRYPTO', 'ALL') | |
| min_net_roi_pct | No | Minimum net ROI percentage required after all exchange taker fees and gas (default: 0.5%) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses that results are net of exchange taker fees and gas and that oracle risk is reported, which is real behavioral context. But it leaves out the operational profile: whether it queries venues live or from cache, scan latency/cost, data freshness, and whether results are ranked. For a potentially expensive cross-venue scan, that is a meaningful gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences, zero filler, with the core action and the returned metrics both front-loaded. Every clause carries information an agent can use.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description's enumeration of returned metrics (net ROI, gross edge cents, combined costs, annualized yield, oracle risk) does real work in explaining the return value. What is missing is scope of coverage โ whether all venues are scanned or only the exemplified pairs โ and freshness, which matters for an arbitrage tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with defaults, ranges and an enum on 'risk', so the schema already documents all four parameters well. The description's mention of net ROI is consistent with min_net_roi_pct but adds no syntax or interpretation beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Find cross-venue matched prediction market arbitrage opportunities') and concretizes it with named venue pairs (Polymarket YES vs Kalshi NO). It also enumerates the metrics computed, so an agent knows this is an analysis/scan tool rather than a raw data fetch. It does not explicitly distinguish itself from siblings like search_prediction_markets or get_market_orderbook, but the arbitrage framing makes the difference inferable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the examples and by the fee-adjusted ROI framing, which signals a screening/opportunity-discovery use case. However, there is no explicit when-to-use vs when-not, no statement of prerequisites (does it need a prior search? does it hit live orderbooks?), and no routing to the sibling tools an agent would need afterwards to inspect an opportunity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_prediction_marketsA
Search active prediction markets across 7 major venues (Polymarket, Kalshi, Limitless, PredictIt, Drift BET, Smarkets, ForecastEx). Filter by keyword, category, status, or specific venue to view live quotes, volume, and liquidity.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of markets to return (1 - 50, default 10) | |
| query | Yes | Search keyword (e.g. 'Trump', 'Fed', 'Bitcoin', 'Election', 'CPI', 'Solana') | |
| venue | No | Venue filter or 'ALL' to search across all exchanges (default: 'ALL') | ALL |
| status | No | Market status ('ACTIVE', 'RESOLVED', 'ALL', default: 'ACTIVE') | ACTIVE |
| category | No | Optional category filter (e.g. 'POLITICS', 'ECONOMICS', 'CRYPTO', 'SPORTS') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does disclose the return payload (live quotes, volume, liquidity) and implies a read-only search over active markets, but it says nothing about rate limits, pagination/caps, whether results are ranked, or what happens with zero matches. For an unannotated tool this is decent but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste, front-loaded with the resource and venue scope before the filter and output details. Nothing to trim.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five well-documented parameters and no output schema, the description covers venues, filters, and the shape of results, which is nearly everything needed to call it. Minor gaps remain around result ordering and empty-result behavior, but nothing blocking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline of 3 applies. The description mirrors the filter set (keyword, category, status, venue) but adds no semantics beyond the schema โ it doesn't explain the limit cap, the 'ALL' venue/status interaction, or whether query can be broadened with empty strings.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb ('Search') plus resource ('active prediction markets') with the exact scope spelled out: seven named venues and the four filter dimensions. An agent can immediately distinguish this discovery tool from siblings like get_market_orderbook or scan_arbitrage_opportunities without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case ('filter ... to view live quotes, volume, and liquidity'), which tells the agent this is the market-discovery entry point. However, it never explicitly routes against the siblings โ nothing says when to prefer this over get_market_orderbook or get_whale_trades, and there are no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.0.0- First observed
calculate_kalshi_fees - First observed
get_market_orderbook - First observed
get_whale_trades - First observed
scan_arbitrage_opportunities - First observed
search_prediction_markets
TDQS
Scored across 5 tools
Each tool has a clearly distinct action-object pair: orderbook depth, arbitrage scanning, market search, fee math, and whale flow. While orderbook and arbitrage both touch pricing data, the descriptions make the boundaries explicit (raw depth vs. cross-venue opportunity detection). No realistic misselection risk.
All five tools follow a strict verb_noun snake_case convention: get_market_orderbook, search_prediction_markets, scan_arbitrage_opportunities, calculate_kalshi_fees, get_whale_trades. Verbs are precise and non-redundant across the set.
Five tools is a tight, well-scoped set for a multi-venue prediction-market analytics server, with no filler. It is slightly thin relative to the breadth claimed (7 venues), leaving no room for market detail lookup or historical data tools, but nothing extraneous exists.
The surface covers the core analytical loop: discover markets, inspect depth/pricing, find cross-venue arbitrage, compute venue-specific fees, and track whale flow. Minor gaps remainโno single-market detail-by-id lookup, historical price series, or venue enumerationโwhich agents can partly work around via search_prediction_markets.
Maintenance
Related MCP Connectors
AI prediction market trading โ real-time data, CLOB exchange, Prop Desk, 40+ tools
Order-book depth & history for Polymarket, Kalshi & Limitless. Keyless demo, key for full access.
Cross-venue prediction market routing for AI agents with arbitrage, quotes, history, and signals.
Keyless prediction-market data across 12 venues plus paper-trading of crypto spot, futures, and PM.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceTrade and monitor prediction markets across Polymarket, Kalshi, Opinion, Limitless, and PredictFun from any AI agent. Unified real-time data, live orderbook streaming, and order execution โ one API key, one interface, five exchanges.-
- AlicenseAqualityDmaintenancePrediction market probability oracle for AI agents. 26 tools across 500+ live markets from Kalshi and Polymarket. Cross-source arbitrage detection, structured TPF signals, Kelly Criterion sizing, agent performance tracking, and webhook alerts.974 npm1MIT
- AlicenseAqualityBmaintenance24/7 autonomous monitoring and edge detection for prediction markets (Kalshi & Polymarket). Features causal tree analysis, orderbook depth tracking, cross-venue comparison, and real-time alerts.16196 npm12MIT

orcalayer-mcpofficial
AlicenseAqualityAmaintenanceEnables smart-money whale and market analytics for Polymarket, including leaderboards, wallet profiles, positions, market clusters, and alerts, through Claude Desktop and other MCP clients.687 PyPI1MIT