This server gives Claude or any MCP client read-only, credential-free access to Polymarket prediction-market data, including a unique ranking of liquidity-reward markets.
search_markets — full-text search across Polymarket events and markets, returning questions, prices, liquidity, volume, and token IDs.
get_market — full detail for one market by ID or slug, enriched with live midpoint and spread per outcome.
get_orderbook — live bids/asks for an outcome token with best bid/ask, midpoint, and spread.
get_price_history — historical probability time series with summary stats and auto-downsampling.
list_reward_markets — rank maker-reward markets by daily reward pool ÷ on-book competition, surfacing the best liquidity-reward opportunities.
get_trader_activity — inspect any wallet's public positions, recent activity, or total portfolio value.
A Model Context Protocol (MCP) server that gives Claude — and any MCP client — read-only access to Polymarket, the largest prediction market. Search markets, pull live order books and price history, inspect any wallet's positions, and rank the liquidity-reward markets by where you actually earn the most per dollar quoted.
No API keys. No wallet. No signup. Every tool runs against Polymarket's public APIs, so it works the second you add it to Claude.
"Claude, find me Polymarket markets paying the most liquidity rewards with the least competition."Most prediction-market tooling stops at "list the markets." This server adds the thing market-makers actually care about: list_reward_markets ranks Polymarket's maker-reward programs by daily reward pool ÷ on-book competition — surfacing where resting liquidity earns the best rate, not just which markets exist.
Built on the official @modelcontextprotocol/sdk, Zod-validated, with graceful error envelopes and a short in-process cache so repeated questions in a single Claude turn stay fast.
Related MCP server: Polymarket MCP Server
claude mcp add polymarket -- npx -y polymarket-mcp-serverAdd this to your claude_desktop_config.json
(~/Library/Application Support/Claude/ on macOS, %APPDATA%\Claude\ on Windows):
{
"mcpServers": {
"polymarket": {
"command": "npx",
"args": ["-y", "polymarket-mcp-server"]
}
}
}Restart Claude Desktop, and the tools appear under the 🔌 menu. That's it — no credentials to configure.
Point any MCP client at the stdio command npx -y polymarket-mcp-server.
Tool | What it does |
| Full-text search across events & markets → questions, prices, liquidity, volume, and token IDs. |
| Full detail for one market (by ID or slug), enriched with live midpoint & spread per outcome. |
| Live bids/asks for an outcome token, with best bid/ask, midpoint, and spread computed. |
| Historical probability time series with summary stats; auto-downsampled for long ranges. |
| The differentiator. Markets paying maker rewards, ranked by pool ÷ competition. |
| Any wallet's public positions, recent activity, or total portfolio value (whale-watching). |
You: Which Polymarket reward markets have the best pool-to-competition right now?
Claude: (calls list_reward_markets)
1. "Will Roberto Sánchez Palomino win the 2026 Peruvian presidential election?"
daily pool $2,000 · max spread 3.5¢ · min size 20 · competition $40.7k · score 0.049
...score = dailyRewardPool / (competitionNotional + 1), where competitionNotional is the notional liquidity (Σ price·size) already resting within the scoring spread on the order book — a proxy for how crowded the reward is.
Claude / MCP client ──stdio──▶ polymarket-mcp-server
│
┌─────────────────────┼─────────────────────┐
▼ ▼ ▼
Gamma API CLOB API Data API
(markets, search) (books, prices, rewards) (wallet positions)Read-only & credential-free — only public endpoints are called.
Zod-validated inputs on every tool; malformed input is rejected cleanly.
Graceful errors — upstream failures come back as readable messages, never raw stack traces.
Short TTL cache (60s) on hot queries to respect public rate limits.
git clone https://github.com/Birantx/polymarket-mcp-server.git
cd polymarket-mcp-server
npm install
npm run build
npm test # end-to-end smoke test against the live public APIsRun it directly over stdio:
node dist/index.jsv0.1 (this release): read-only tools, credential-free.
v0.2 (demand-driven): optional authenticated order placement via the CLOB client, gated behind explicit key configuration.
This is an unofficial, community-built tool and is not affiliated with Polymarket. It is read-only and for informational use. Nothing here is financial advice. Prediction markets may be restricted in your jurisdiction.
MIT © 2026 — see LICENSE.
Keywords: Polymarket MCP server, Model Context Protocol, Claude, Anthropic, prediction markets, market making, liquidity rewards, MCP tools, AI trading research.
Fetch full detail for a single market by numeric ID or slug, enriched with a live CLOB midpoint and spread for each outcome token. Use after search_markets when you need depth on one specific market.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Market numeric ID (e.g. '703258') or slug (e.g. 'will-jesus-christ-return-before-2027') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that response includes live CLOB midpoint and spread. No annotations provided, so description carries full burden; could mention auth or side effects but is sufficient for a read operation.
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: first states action and enrichment, second gives usage context. No wasted words.
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?
Complete for a single-parameter tool; covers input format, output enrichment, and usage sequence relative to siblings. No output schema needed as description explains response key features.
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?
Adds value to the schema by explaining the parameter can be either numeric ID or slug, beyond the schema's generic description. Schema coverage is 100%, so this is extra context.
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?
Clearly states the tool fetches full detail for a single market by ID or slug, enriched with CLOB midpoint and spread. Distinguishes from siblings like search_markets which returns multiple markets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises to use after search_markets when needing depth on one specific market, providing clear when-to-use context and excluding use for multiple markets.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Live bids/asks for one outcome token, with computed best bid, best ask, midpoint, and spread. Bids are returned highest-first and asks lowest-first (the top of book), truncated to depth levels.
| Name | Required | Description | Default |
|---|---|---|---|
| tokenId | Yes | CLOB token ID (the long numeric string from a market's outcome; get it via search_markets or get_market) | |
| depth | No | How many price levels per side to return (default 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses ordering (bids highest-first, asks lowest-first) and truncation to depth levels, which is helpful. However, with no annotations, it lacks details on auth requirements, data freshness (e.g., how 'live' it is), or any side effects. This is adequate but not comprehensive.
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 that are efficient and front-loaded. Every clause adds value: the verb 'get', the resource 'order book for one token', computed fields, ordering, and truncation. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description hints at return structure (best bid, ask, midpoint, spread, and arrays of bids/asks in order). This is fairly complete for a simple order book tool, though a brief note on the format could elevate it further.
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 schema already describes both parameters. The description adds only the context that depth truncates levels, which is already implied by the schema description. No substantial new meaning is added beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves live bids/asks for a single outcome token with computed values. It distinguishes well from sibling tools like get_market (market details) or get_price_history (historical prices), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for obtaining order book data for a token and specifies truncation behavior. While it doesn't explicitly state when not to use or list alternatives, the context from sibling names provides enough differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Historical mid-price time series for one outcome token. Returns summary stats (first/last/min/max, change) plus the raw points (Unix seconds t, probability p). Large series are downsampled to keep responses compact.
| Name | Required | Description | Default |
|---|---|---|---|
| tokenId | Yes | CLOB token ID of the outcome to chart | |
| interval | No | Look-back window (default '1w') | |
| fidelity | No | Resolution in minutes between data points (e.g. 60 = hourly). Defaults per interval if omitted. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that large series are downsampled to keep responses compact, and mentions the return format (summary stats + raw points). This is transparent about behavior, though it could mention authentication 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, no wasted words, clearly front-loaded with the core purpose. Every sentence adds value.
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?
Given the tool has 3 parameters, no output schema, and moderate complexity, the description covers the essential aspects (what is returned, summary stats, raw points, downsampling). It is complete enough for an agent to understand usage, though some might want more detail on output structure.
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% with detailed descriptions, so the description adds limited extra value. The mention of downsampling relates to fidelity but does not significantly enhance understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides 'Historical mid-price time series for one outcome token' with summary stats and raw points, distinguishing it from siblings like get_market or get_orderbook which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what the tool does but does not explicitly state when to use it vs alternatives or when not to use it. The context is clear, but no exclusions or alternative guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Public, read-only look at any wallet's Polymarket footprint — open positions, recent activity, or total portfolio value. Useful for whale-watching and copy-research. No credentials needed; uses only on-chain/public data.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | Wallet address (0x...) of the trader to inspect | |
| view | No | positions = open holdings (default); activity = recent on-chain actions; value = total portfolio value | |
| limit | No | Max rows for positions/activity views (default 25) | |
| offset | No | Pagination offset for positions/activity |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It correctly declares the tool as 'Public, read-only' and states it uses 'on-chain/public data', indicating no authentication or side effects. It doesn't mention rate limits or data freshness, but these are minor omissions.
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 efficiently cover purpose, scope, use cases, and access requirements. No wasted words; every sentence earns its place. Front-loaded with the core function.
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?
Given the tool's complexity (4 parameters, no output schema, no annotations), the description adequately covers purpose, access, and use cases. It doesn't mention pagination or response format, but the schema parameters (limit, offset) imply pagination, and output format is not required. Minor gap, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds some context about views but essentially repeats the schema's enum values. Baseline of 3 is appropriate as the description doesn't provide significant extra semantic value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides a 'Public, read-only look at any wallet's Polymarket footprint' with specific views (positions, activity, value). It distinguishes itself from sibling tools like get_market and get_orderbook, which focus on market data, not trader activity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly suggests use cases ('whale-watching and copy-research') and access requirements ('No credentials needed'). While it doesn't mention when not to use it, the context is clear and sufficient given sibling tool focus.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
THE differentiator: lists markets currently paying maker (liquidity) rewards, ranked by daily reward pool ÷ in-band competition — i.e. where you earn the most rewards per dollar of resting liquidity. Each row includes the daily pool, max scoring spread, min order size, and the measured competition (notional resting within the scoring band). Credential-free.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many ranked reward markets to return (default 10) | |
| measureCompetition | No | If true (default), fetch each finalist's order book to measure in-band competition and rank by pool ÷ competition. If false, rank by raw daily pool only (fewer API calls). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description discloses its credential-free nature, output fields, and ranking methodology. It does not cover potential rate limits or caching behavior, but for a list operation, the transparency is good.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences), front-loaded with value proposition, and every sentence adds essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description fully specifies output fields (daily pool, max scoring spread, etc.) and ranking logic, covering all necessary context for a list tool with two parameters.
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?
Both parameters are fully described in the schema (100% coverage), and the description adds meaningful context, particularly for measureCompetition, explaining its effect on ranking and API calls.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists markets paying maker rewards ranked by reward per dollar of liquidity, distinguishing it from sibling tools like search_markets by focusing on liquidity-reward markets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly frames itself as 'THE differentiator' and explains the ranking rationale, implying use for maximizing reward efficiency. It lacks explicit when-not-to-use guidance but provides clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Full-text search across Polymarket events and their markets. Returns matching events with each market's question, outcome prices, liquidity, and volume. Use this first to discover markets and their token IDs (token IDs feed get_orderbook / get_price_history).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Free-text search, e.g. 'US election', 'bitcoin 100k', 'premier league' | |
| limit | No | Max events to return per type (default 10) | |
| activeOnly | No | Restrict to currently-active/tradable events (default true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It explains what is returned (question, prices, liquidity, volume) and implies read-only behavior. It does not mention rate limits, authentication needs, or data staleness, which would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with purpose and output, and includes actionable guidance. Every sentence adds value with no redundant words.
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?
Despite lacking an output schema, the description sufficiently explains the return structure (events with question, prices, liquidity, volume, token IDs). No mention of pagination or total results, but the limit parameter partially addresses this.
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%, with clear descriptions for each parameter. The description adds value by contextualizing the output (token IDs for downstream tools) but does not add parameter-specific meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs full-text search across Polymarket events and markets, returning specific fields. It distinguishes from siblings by noting that token IDs feed other tools like get_orderbook and get_price_history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this first to discover markets and their token IDs', providing sequential guidance. However, it does not explicitly state when not to use it or list alternatives for other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clearly distinct purpose: market details, order book, price history, trader activity, reward markets, and search. There is no overlap or ambiguity.
All tool names follow a consistent verb_noun pattern (get_*, list_*, search_*), making it easy to predict and remember.
With 6 tools, the server covers all essential read operations for Polymarket data without being overly numerous or too few.
The tool set provides a comprehensive read-only surface: market discovery, details, order book, price history, reward markets, and trader activity. No obvious gaps for its purpose.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Polymarket MCP — prediction-market data via Gamma + CLOB public APIs.
Live prediction markets: Polymarket + Kalshi prices, odds, order books. Pay-per-call USDC, no key.
Order-book depth & history for Polymarket, Kalshi & Limitless. Keyless demo, key for full access.
Live Polymarket data for agents: markets, insider-scored whale trades, leaderboards, wallet P&L
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Birantx/polymarket-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
