DEV Community: ekocam

Giving Claude live Polymarket data with an MCP server

ekocam — Sat, 25 Jul 2026 19:05:56 +0000

Large language models are good at reasoning about numbers and bad at knowing them. Ask Claude which Polymarket wallets are actually profitable and you will get a confident answer assembled from training data that was already stale when the model shipped.

The Model Context Protocol fixes that by letting the model call your data directly. This post walks through a working example: a small MCP server that puts live Polymarket whale analytics into Claude Desktop, Cursor, or any other MCP client.

The server is open source and MIT licensed, so you can read the whole thing: github.com/orcalayer/orcalayer-mcp.

What MCP actually does

An MCP server exposes three kinds of capability to a model:

Tools the model can call, with typed arguments and structured results
Prompts the user can pick from a menu, which orchestrate several tools at once
Resources the model can read directly as context, without spending a tool call

That third one matters more than people expect. A methodology document loaded as a resource means the model knows how your numbers are defined before it starts interpreting them.

Setup

The server is a stdio wrapper over the Python SDK, so there is nothing to deploy. Add it to your claude_desktop_config.json:

{
  "mcpServers": {
    "orcalayer": {
      "command": "uvx",
      "args": ["orcalayer-mcp"]
    }
  }
}

On Windows the file lives at %APPDATA%\Claude\claude_desktop_config.json, on macOS at ~/Library/Application Support/Claude/claude_desktop_config.json. Restart the app after editing.

That is the whole install. uvx fetches and runs the package on demand, so there is no virtualenv to manage.

The tools

Five tools, four of which need no key at all:

Tool	What it does	Key
`leaderboard`	Rank smart-money whales by P&L, win rate or volume	No
`wallet_overview`	A wallet's profile and performance summary	No
`wallet_positions`	A wallet's largest open positions	No
`markets`	Search markets where smart whales are clustering	No
`whale_alerts`	Live feed of recent smart-whale trades	Premium

For the Premium tool, pass the key through the environment rather than hardcoding it:

{
  "mcpServers": {
    "orcalayer": {
      "command": "uvx",
      "args": ["orcalayer-mcp"],
      "env": { "ORCALAYER_API_KEY": "your_key_here" }
    }
  }
}

Prompts do the orchestration

The part worth stealing for your own server is the prompt layer. Rather than making the user chain tool calls by hand, ship prompts that encode the workflow you actually want:

Prompt	What it does
`analyze_wallet`	Full wallet analysis: smart money or farmer?
`find_divergence`	Markets where smart money disagrees with the current price
`hedge_check`	Whether a wallet's profit was real alpha or a hedge structure
`territorial_markets_review`	Ukraine territorial markets with an ISW frontline overlay

hedge_check is the one I would point at if you are building something similar. A wallet that holds both sides of the same market can post a spectacular profit number that means nothing directionally. A naive integration reports that as alpha. Encoding the check as a prompt means the model runs it every time instead of only when the user thinks to ask.

That is the general lesson: your domain knowledge belongs in the prompts, not in the user's head.

Resources for definitions

Three resources load as plain context:

orcalayer://methodology covers how smart money is separated from farmers, hedgers and market makers
orcalayer://glossary is a prediction-markets glossary
orcalayer://api-reference is the REST API reference, including auth and rate limits

If your data has any non-obvious definitions, and analytics data always does, put them in a resource. It costs nothing at query time and stops the model from inventing its own interpretation of your columns.

One design note on honest nulls

The Premium stream now tags every event with a settlement_type of MINT, MERGE, COMPLEMENTARY or null, describing how a match settled rather than what the trader intended.

The null is deliberate. It means the pipeline could not determine the settlement type, not that the trade was something else. It is tempting to collapse an unknown into a default, and it is almost always the wrong call: a model reading your data cannot tell a real zero from a missing one, so it will treat your guess as fact. Return the honest null and let the caller decide.

Try it

Which Polymarket wallets have the best win rate right now,
and are any of them just farming near-settled markets?

Ask that in Claude Desktop with the server connected and it will call leaderboard, then run the farmer check from the methodology resource, and tell you which of the top names are not what they look like.

The server is MIT licensed at github.com/orcalayer/orcalayer-mcp, and the underlying REST API is documented at orcalayer.com/docs/api. Data is for informational purposes only and is not financial advice.

A REST API for Polymarket Whale Data: A Developer Guide

ekocam — Sun, 19 Jul 2026 12:34:32 +0000

If you want Polymarket whale data in your own code, a dashboard, a trading model, or an AI agent, you need an API, not a website. Here is what the OrcaLayer REST API exposes and how to start.

How do developers access a Polymarket REST API?

Through the OrcaLayer API. It is a plain REST API over the same index the site runs on: over 1.2 billion trades read directly from the Polygon chain, farmer-filtered. Full access is on the Premium tier (19.99 dollars a month) at 600 requests per minute. Some read endpoints, wallet profiles, market search and the leaderboard, need no key at all, so you can prototype before paying anything.

Quickstart

Sign up and upgrade to Premium.
Go to Settings, API Keys, and generate a key. It uses the sk_orca_ prefix and is shown once.
Call the API:

curl -H "Authorization: Bearer sk_orca_XXXXXX" \
  "https://orcalayer.com/api/public/v1/whales/leaderboard?limit=10"

Authentication works either as a Bearer token in the Authorization header or as an x-api-key header. Premium endpoints under /api/v2 expect x-api-key specifically. A missing or invalid key returns 401, a non-Premium plan on a Premium endpoint returns 403, and passing the rate limit returns 429 with a Retry-After header.

What the API exposes

Whale leaderboards, farmer-filtered, with win rate, profit and profit factor
Individual wallet profiles and full trade histories
Recent whale trades and whale position flips
Per-market whale activity
Whale alerts data, the same stream that powers the alerts feed
ISW Ukraine territory data

The numbers match what the site shows, because it is the same index and the same published methodology, including the farmer filter and NegRisk correction.

Clients and tooling

You do not have to start from raw REST:

Python SDK: pip install orcalayer
MCP server for AI agents: uvx orcalayer-mcp, so Claude or any MCP-capable agent can query whale data directly
Claude Code agent skill for terminal workflows
A whale watchlist monitor and a backtest cookbook as ready-made starting points
OpenAPI spec at https://orcalayer.com/api/openapi.json for generating typed clients in any language

All of them are linked from the API docs at orcalayer.com/docs/api.

What to build on it

At 600 requests per minute you can poll a watchlist of wallets every few seconds and drive your own alerting, mirror the leaderboard into your own database, backtest wallet-following strategies against real resolved markets, or feed an AI agent live whale context through MCP.

FAQ

Is there a REST API for Polymarket whale analytics?
Yes. The OrcaLayer REST API serves whale leaderboards, wallet profiles and trades, whale alerts, market whale activity and ISW territory data over plain REST. Full access is on the Premium tier at 600 requests per minute; some read endpoints such as wallet profiles, market search and the leaderboard need no key at all.

How do I authenticate?
Generate a key in Settings, API Keys, then send it as a Bearer token in the Authorization header or as an x-api-key header. Keys use the sk_orca_ prefix and are shown only once at creation.

Is there a Python SDK?
Yes, pip install orcalayer. There is also an MCP server for AI agents (uvx orcalayer-mcp), a Claude Code agent skill, a whale watchlist monitor and a backtest cookbook.

What are the rate limits?
Premium runs at 600 requests per minute. Exceeding the limit returns HTTP 429 with a Retry-After header.

Originally published on orcalayer.com.

Most "top traders" on Polymarket are farming win rate. I backtested it.

ekocam — Tue, 30 Jun 2026 13:42:21 +0000

If you've looked at a "top traders" leaderboard on Polymarket and thought about copy-trading the top wallets, I have some bad news: a lot of those flawless 95%+ win-rate records are farmed, not earned. I pulled the on-chain data and backtested it, and the raw leaderboard turns out to be a pretty bad signal to copy. Here's the breakdown, with reproducible notebooks at the end.

The farming trick

It's simple. You only ever buy outcomes that are already basically decided, priced around 95-99c.

Think of a market like "Will X happen?" sitting at 99c the day before it resolves. You put up 99c to make 1c. You win almost every time. Do this across enough near-decided markets and you end up with a 95%+ win rate and a clean, green, very impressive-looking record.

But the edge is basically zero, and more importantly for a copy-trader: it's unfollowable. You can't get filled at 99c at any real size, and you're risking 99 to make 1. The win rate is real in the data and useless in practice.

Raw P&L and win-rate leaderboards reward exactly this behavior. So the wallets that look best are often the ones you least want to copy.

Measuring it properly

A few things matter when you compute this from raw on-chain data, or the numbers come out wrong:

NegRisk consolidation. Polymarket's multi-outcome markets settle through a NegRisk adapter. If you don't consolidate the legs, you double-count and P&L inflates. (The public data API's cashPnl has this problem - I don't use it as cost-basis truth.)
FIFO cost basis, per wallet per market. Matching sells against buys in order, not averaging blindly.
Win rate per resolved market, not per trade. A wallet that makes 40 trades in one market that resolves in its favor didn't win 40 times.

With that in place, I split the leaderboard into two cohorts to copy:

Raw top 8 by cumulative P&L (farmers included).
Filtered top 8 - same board with farmers and hedgers removed.

Then I backtested copying each one as an equal-weight equity curve across resolved markets.

The result

Honest read: for most of the window the two curves basically track each other. The filtered cohort only pulls ahead near the end, and not by a huge margin (~33M vs ~27M in this run). I'm not going to oversell "filtering wins on P&L" - that gap is small and probably sample-dependent. Both curves are lumpy too; a few big resolutions carry most of the move, which is kind of the point - these are near-decided markets resolving.

What I'd actually stand behind: the raw leaderboard is built on those unfollowable ~99c fills, so copying it is a bad idea regardless of the cumulative number. The win rate on those boards is mostly noise. If you're building a copy-trading strategy, "who has the highest win rate" is close to the worst possible wallet-selection signal.

Small sample (8 per cohort), so take the exact numbers with a grain of salt. The interesting part isn't the dollar figure, it's the mechanism.

Reproduce it

The notebooks are open source (MIT) so you can re-run this on a different set of wallets or a different time window and check whether the filtered edge holds out of sample - genuinely curious if it does:

github.com/orcalayer/polymarket-backtest-cookbook

Three notebooks: follow one wallet's resolved bets as an equity curve, follow a smart-money cohort by category, and the raw-vs-filtered comparison above.

The data comes from OrcaLayer, which is a data layer I build over Polymarket (every trade read straight from the Polygon chain, then classified - farmer filtering, NegRisk-correct win rates, FIFO P&L). The leaderboard endpoint is keyless so the notebooks run free; per-wallet backtests use an API key.

If you go deeper into prediction-market data, I'd love feedback on the methodology - especially the NegRisk and FIFO handling, which is where most of the subtlety lives.