# Polymarket (npm · @pipeworx/mcp-polymarket)

Polymarket MCP — prediction-market data via Gamma + CLOB + Data public APIs.

- Trust score: 80/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `gateway.pipeworx.io`: 78/100, [markdown](https://verifymcp.io/servers/pipeworx-io-polymarket/polymarket-mcp.md), [page](https://verifymcp.io/servers/pipeworx-io-polymarket/polymarket-mcp)
- npm · `@pipeworx/mcp-polymarket`: 80/100 (this document), [markdown](https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket.md), [page](https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket)

## Channel facts

- Registry: `npm`
- Package: `@pipeworx/mcp-polymarket`
- Version: `0.2.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to pipeworx-io/mcp-polymarket).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3126 tokens (~240/item across 13 items; 13 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (31% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 13 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 14 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Polymarket MCP server?

Polymarket runs locally as an npm package, launched with npx -y @pipeworx/mcp-polymarket. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add pipeworx-io-polymarket -- npx -y @pipeworx/mcp-polymarket
```

### Cursor

```json
{
  "mcpServers": {
    "pipeworx-io-polymarket": {
      "command": "npx",
      "args": [
        "-y",
        "@pipeworx/mcp-polymarket"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "pipeworx-io-polymarket": {
      "command": "npx",
      "args": [
        "-y",
        "@pipeworx/mcp-polymarket"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add pipeworx-io-polymarket -- npx -y @pipeworx/mcp-polymarket
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "pipeworx-io-polymarket": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@pipeworx/mcp-polymarket"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add pipeworx-io-polymarket --command npx --arg -y --arg @pipeworx/mcp-polymarket
```

### Hermes

```yaml
mcp_servers:
  pipeworx-io-polymarket:
    command: "npx"
    args: ["-y", "@pipeworx/mcp-polymarket"]
```

### Netclaw

```json
{
  "McpServers": {
    "pipeworx-io-polymarket": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@pipeworx/mcp-polymarket"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add pipeworx-io-polymarket -t stdio -c npx -a -y @pipeworx/mcp-polymarket
```

### Other

```json
{
  "mcpServers": {
    "pipeworx-io-polymarket": {
      "command": "npx",
      "args": [
        "-y",
        "@pipeworx/mcp-polymarket"
      ]
    }
  }
}
```

## Changelog

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

### 2026-11-05 (score 80, +1)

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

### 2026-11-04 (score 79)

First indexed and scored.

## MCP tools (13)

### `polymarket_search` (~174 tokens)

PREFER OVER WEB SEARCH for current betting/prediction-market odds. Real-time search across Polymarket events — returns events matching your keyword, each with child markets carrying live Yes/No prices in [0,1] (= implied probability), 24h volume, end date, resolution criteria. Use for "what are the odds of X", "what does the market think about Y", "what's the implied probability of Z". Refreshes every few minutes; covers ~10k active markets across politics, crypto, sports, macro events.

Input parameters:

- `include_closed` (boolean): Include resolved markets (default false)
- `limit` (number): 1–25 events (default 5)
- `query` (string, required): Search query, e.g. "presidential election", "rate cut", "world cup"

### `polymarket_top_markets` (~215 tokens)

Highest-volume OPEN Polymarket markets right now — sorted by trading volume in the chosen window (24hr / 1wk / 1mo / 1yr / all). The "where is real money going this week" lens. Use for "what is the market focused on right now", "biggest trades happening today", or as a discovery tool when you don't have a specific question. Each result has live yes/no prices in [0,1] = implied probability.

Input parameters:

- `limit` (number): 1–100 per page (default 10)
- `offset` (number): Pagination offset into the volume-ranked list (default 0). Use offset=100 (with limit=100) to fetch ranks 101–200, offset=200 for 201–300, etc. — walk the pages to build a true top-N-by-volume set.
- `window` (string): 24hr | 1wk | 1mo | 1yr | all (default 24hr)

### `polymarket_market` (~209 tokens)

AUTHORITATIVE detail for a single Polymarket market by slug or numeric id. Returns the resolution criteria text (so you know exactly what "Yes" means before quoting odds), current Yes/No prices in [0,1], 24h volume, liquidity USD, end date, parent event. Use after polymarket_search to drill in, or when the agent already has a Polymarket URL/slug. For real-time orderbook depth instead of a summary, see polymarket_orderbook.

Input parameters:

- `slug_or_id` (string, required): Market slug (e.g. "will-bitcoin-hit-150k-by-december-31-2027") or numeric id. A dated slug still resolves after it settles — this tool automatically retries a closed-market lookup when the bare looku…

### `polymarket_event` (~199 tokens)

Get a Polymarket event with EVERY child market at once. Events group RELATED outcomes (e.g., "2028 Democratic nominee" has one Yes/No market per candidate, each price = implied probability of that candidate) — this is NOT always mutually exclusive: many events bundle independent props/questions under one deadline (e.g. per-senator vote markets) where multiple legs can resolve YES together. Check the returned `neg_risk` field (event- and market-level) before assuming the child markets sum to ~1 — only `neg_risk: true` means Polymarket has verified exclusivity. Use when you need the full slate — election candidates, championship contenders, multi-option outcomes — instead of one specific market. Returns event metadata + array of child markets with live prices, volumes, end dates.

Input parameters:

- `slug_or_id` (string, required): Event slug (e.g. "2028-presidential-election") or numeric id

### `polymarket_price_history` (~301 tokens)

Historical probability time-series for one Polymarket market. Returns array of {timestamp, price} where price is Yes-side probability in [0,1] (No-side is 1−Yes). Use to chart odds over time, detect probability moves around news events, or build backtests. Intervals 1h | 6h | 1d | 1w | 1m | max — supports up to a month (1m) and full history (max). A young market may have less data than the requested window; the `coverage` field reports the actual span and whether it is the full available history (a data limit, not a tool limit).

Input parameters:

- `end` (string): ISO datetime or epoch seconds. Requires `start`.
- `interval` (string): 1h | 6h | 1d | 1w | 1m | max (default 1d). Higher fidelity for shorter windows. Intervals are measured back from NOW, so a market that closed more than an interval ago returns nothing -- use start/en…
- `slug_or_id` (string, required): Market slug or numeric id (same as polymarket_market)
- `start` (string): ISO datetime or epoch seconds. With `end`, reads exactly [start, end] at the interval's fidelity instead of the last `interval` back from now -- the way to read a market that has already closed.

### `polymarket_orderbook` (~145 tokens)

REAL-TIME CLOB orderbook for one Polymarket market — bid/ask ladder on both YES and NO sides with size at each price level. Use to check actual tradable depth before quoting a size estimate; the `liquidity` field on polymarket_market is a rolled-up summary, this is the actual ladder. Returns yes_bids[], yes_asks[], no_bids[], no_asks[] each as [price, size] pairs sorted from inside the book outward. Necessary input before any "you could buy $X at price Y" answer — without depth that's a guess.

Input parameters:

- `slug_or_id` (string, required): Market slug or numeric id

### `polymarket_event_books` (~227 tokens)

Batched CLOB orderbooks for EVERY tradable market in one Polymarket event — single round trip via the CLOB batch /books endpoint. Use before any multi-leg strategy (partition arbitrage "SELL/BUY EVERY LEG", basket trades) to check per-leg depth: theoretical overround means nothing if half the legs are 50-share books. Returns legs[] with {slug, question, yes_price, best_bid, best_ask, yes_bids[], yes_asks[]} where bids are sorted best(highest)-first and asks best(lowest)-first as {price, size} objects. Pass include_no=true to also fetch NO-side books (doubles payload — only needed for NO-leg strategies). Caps at 80 legs (highest yes_price kept; truncated_legs reports the cut).

Input parameters:

- `event_slug_or_id` (string, required): Event slug (e.g. "fed-decision-may-2026") or numeric id — same input as polymarket_event.
- `include_no` (boolean): Also fetch NO-side books for each leg (default false).

### `polymarket_trades` (~465 tokens)

Recent EXECUTED trades (the fills tape) for a Polymarket market — actual money that changed hands, newest first. Each trade: side (BUY/SELL), outcome (Yes/No or the option name), outcome_index, size (shares), price (that fill's OWN outcome's price), unix, timestamp, and the trader's wallet/pseudonym. Use for "what's the recent order flow", "is smart money buying Yes", "how much just traded and at what price". DISTINCT from polymarket_orderbook (resting/unfilled orders — intent) and polymarket_price_history (the CP time-series). Pass a market slug or numeric id (same input as polymarket_market). PAGING: `limit` goes to 1000; follow `next_cursor` to walk further back. To measure a whole time window rather than the tail (e.g. what takers actually paid across one 15-minute crypto window) pass `window_start` (+ `window_end`): the tool walks the tape back to the window start itself and returns `coverage` saying whether the walk reached it or ran out of page budget, plus a size-weighted `per_minute` fill-price summary on the first outcome's side.

Input parameters:

- `cursor` (string): Opaque cursor from a previous call's `next_cursor` — continues the newest-first tape further back. Omit for the newest page. Ignored in window mode.
- `limit` (number): Trades per page / trades returned, 1-1000 (default 20; in window mode default 100).
- `max_pages` (number): Window mode only: page budget, 1-20 (default 8, 1000 fills each). If the walk hits it before reaching window_start, coverage.complete is false.
- `slug_or_id` (string, required): Market slug (e.g. "will-trump-win-2024") or numeric id — same input as polymarket_market.
- `window_end` (string): ISO datetime or epoch seconds, exclusive (default: now). Only used with window_start.
- `window_start` (string): ISO datetime or epoch seconds. Switches to window mode: walks the whole tape back to this instant. Inclusive.

### `polymarket_holders` (~134 tokens)

Largest position holders for a Polymarket market, per outcome — who holds the most Yes and the most No shares, with share amounts and trader pseudonyms. Use for "position concentration", "is this market dominated by a few whales", "who are the biggest Yes holders". Reveals conviction/concentration that price alone hides. Pass a market slug or numeric id (same input as polymarket_market).

Input parameters:

- `limit` (number): Top N holders per outcome to return (1-100, default 10)
- `slug_or_id` (string, required): Market slug or numeric id — same input as polymarket_market.

### `polymarket_wallet_positions` (~272 tokens)

Open and closed positions for one Polymarket wallet — size, entry basis, current mark, and realized/unrealized P&L per position, plus portfolio-level exposure and concentration (how much of the wallet's capital sits in its single largest position — a concentration measure, not a measure of trading skill). Wallet addresses are public on-chain identifiers (0x…), looked up directly — no name/ENS resolution. Omit `status` to get OPEN + CLOSED together in one call; pass a specific status to filter. Use for "what is this wallet holding", "how exposed is this wallet to market X", "is this wallet up or down overall".

Input parameters:

- `cursor` (string): Opaque pagination cursor from a previous call's `next_cursor` — omit for the first page.
- `limit` (number): Rows per page, 1-500 (default 50).
- `status` (string): OPEN | CLOSED | REDEEMABLE | REDEEMABLE_LOST | MERGEABLE — filter to one lifecycle state. Omit to fetch OPEN and CLOSED together (default).
- `wallet` (string, required): Polymarket proxy wallet address, 0x-prefixed (40 hex chars). Get one from polymarket_holders or polymarket_trades on a market of interest.

Output parameters:

- `data_as_of` (string): ISO timestamp when this response was fetched live from Polymarket Data API v2.
- `largest_position_share_of_exposure` (number|null): Largest single position's current_value as a fraction of total current_value — concentration, not skill.
- `next_cursor` (string|null)
- `position_count` (number)
- `positions` (array)
- `total_current_value_usdc` (number|null)
- `total_realized_pnl_usdc` (number|null)
- `total_unrealized_pnl_usdc` (number|null)
- `wallet` (string)

### `polymarket_wallet_activity` (~272 tokens)

Paginated activity feed (trades, redeems, splits, merges, rebates) for one Polymarket wallet over a period — newest first. Use for "what has this wallet done recently", "show me this wallet's trade history", "did this wallet trade market X". Distinct from polymarket_wallet_positions (current holdings) and polymarket_wallet_performance (aggregated P&L) — this is the raw event-by-event tape. Follow `next_cursor` to page past the current window.

Input parameters:

- `cursor` (string): Opaque pagination cursor from a previous call's `next_cursor` — omit for the first page.
- `end_date` (string): ISO date/datetime — only activity at or before this time (default: no upper bound).
- `limit` (number): Rows per page, 1-500 (default 50).
- `start_date` (string): ISO date/datetime — only activity at or after this time (default: no lower bound).
- `type` (string): Filter to one activity type, e.g. TRADE, REDEEM, SPLIT, MERGE, MAKER_REBATE (default: all types).
- `wallet` (string, required): Polymarket proxy wallet address, 0x-prefixed (40 hex chars).

Output parameters:

- `activity` (array)
- `activity_count` (number)
- `data_as_of` (string): ISO timestamp when this response was fetched live from Polymarket Data API v2.
- `next_cursor` (string|null)
- `wallet` (string)

### `polymarket_wallet_performance` (~299 tokens)

Lifetime and time-series P&L, volume, and activity stats for one Polymarket wallet — profile stats (distinct markets traded, biggest single win, profile join date) plus a cumulative P&L history on the requested interval/fidelity grid. States fee treatment explicitly: `realized_pnl` in each point is already NET of taker fees paid; maker rebates and other non-trading income (rewards, referrals) are reported separately in `wallet_income` and are additive on top, not already included in `realized_pnl`. Use for "is this wallet profitable overall", "how has this wallet's P&L moved over time", "how active is this wallet". Coverage: Polymarket's own PnL ledger starts from when the wallet's positions were first tracked — `source_fidelity` on each point says whether it is a native observation or synthesized onto a finer grid.

Input parameters:

- `fidelity` (string): Grid step for the P&L series: 1h | 3h | 12h | 18h | 1d (default 1d). Finer grids only available for shorter intervals.
- `interval` (string): 1d | 1w | 1m | all | max — the P&L history window (default max).
- `wallet` (string, required): Polymarket proxy wallet address, 0x-prefixed (40 hex chars).

Output parameters:

- `data_as_of` (string): ISO timestamp when this response was fetched live from Polymarket Data API v2.
- `fee_treatment` (string)
- `pnl_history` (array)
- `profile` (object)
- `wallet` (string)

### `polymarket_resolution_status` (~161 tokens)

Resolution lifecycle state and timestamps for one Polymarket market: initialized / posed / proposed / challenged / reproposed / disputed / resolved (or active/arbitration), whether it was disputed, the reporter (UMA_OO / Chainlink / EOA), and — once resolved — the exact resolution timestamp and per-outcome payouts. Use for "has this market actually settled yet", "when did market X resolve", "was this resolution disputed" — distinct from polymarket_market's `closed`/`active` flags, which reflect trading status, not oracle finality. Pass a market slug or numeric id (same input as polymarket_market).

Input parameters:

- `slug_or_id` (string, required): Market slug or numeric id — same input as polymarket_market.

Output parameters:

- `data_as_of` (string): ISO timestamp when this response was fetched live from Polymarket Data API v2.
- `expected_settlement_time` (string|null)
- `extended_review` (boolean)
- `market_slug` (string)
- `payouts` (array|null)
- `question` (string)
- `reporter` (string|null)
- `resolved_at` (string|null)
- `status` (string)
- `was_disputed` (boolean)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket#diagnostics

## Score history

- 2026-11-05: 80
- 2026-11-04: 79

## Common questions

### What is the Polymarket MCP server?

Polymarket is an MCP server listed in the public MCP registry as io.github.pipeworx-io/polymarket. Polymarket MCP, prediction-market data via Gamma + CLOB + Data public APIs. This page covers its npm package (@pipeworx/mcp-polymarket).

### Is the Polymarket MCP server safe to use?

Polymarket scores 80 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Polymarket MCP server expose?

Polymarket exposes 13 tools: polymarket_search, polymarket_top_markets, polymarket_market, polymarket_event, polymarket_price_history, and 8 more. Their descriptions and schemas cost roughly 3,073 tokens of context every time the server is loaded.

### Is the Polymarket MCP server still maintained?

Polymarket is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Polymarket MCP server under?

Polymarket declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@pipeworx/mcp-polymarket
- Socket report: https://socket.dev/npm/package/@pipeworx/mcp-polymarket
- Repository: https://github.com/pipeworx-io/mcp-polymarket
- Website: https://pipeworx.io/packs/polymarket
- Changelog RSS feed: https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket.xml
- Changelog JSON feed: https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket.json
- HTML version of this page: https://verifymcp.io/servers/pipeworx-io-polymarket/pipeworx-mcp-polymarket