- Claude Desktop ·
CodeClients - stdio or HTTPTransports
- 12 tools ·
2 resourcesSurface - Every tierAccess
Once Claude can call the market data directly, "what is the BTC Up/Down book doing?" stops being a guess and becomes a tool call. This is the connection how-to, how to point Claude Desktop or Claude Code at the MCP server, which transport to choose, and what each tool does in practice once the agent is live. No configuration code, just the steps.
The MCP server is a small program that exposes the whole Resolved Markets API as tools an agent can call. Every tier gets it, Free included, so the only thing that changes by plan is how much you can pull, not what you can connect. You will need one thing in hand before you start: an API key.
Pick your transport first
stdio, local
For Claude Desktop or Claude Code on your own machine, the agent launches the server as a local process and talks to it over standard input and output.
- Runs on your machine
- No network exposure
- Simplest to start
HTTP, remote
For a shared or always-on setup, the same server runs over HTTP so multiple clients can reach one running instance.
- Shared instance
- Multi-client
- Same tool surface
Your key, your tier
Either transport carries your API key, so the agent inherits your tier’s rate limit and credit budget, nothing more, nothing less.
- Key-scoped access
- Tier rules apply
- Same as REST
The tool surface is identical across both, the transport only changes how the client reaches the server. Start with stdio on a single machine; reach for HTTP when more than one client needs the same instance.
Connecting Claude Desktop or Claude Code
- 1Generate an API key from the api-keys page, this is what scopes the agent to your tier’s limits and credits.
- 2Install the MCP server locally so Claude can launch it as a stdio process, following the steps on the AI Agents guide.
- 3Register the server with your client, Claude Desktop and Claude Code both read a small MCP configuration that names the server command and passes your key as an environment value.
- 4Choose the transport: leave it on stdio for a single local machine, or switch the server to HTTP mode when a shared instance needs to serve several clients.
- 5Restart the client and confirm the tools appear, ask the agent to list categories, and a successful call means the connection is live.
Every tier connects the full surface
MCP is not gated behind a paid plan. Free, Pro, Scale, and Enterprise all connect the same 12 tools and 2 resources. The tools draw on your API key, so they share its rate limit and credit budget, paid tiers simply raise both for heavier agent work. What you can call is identical; how much you can pull is what scales.
What each tool does in practice
Twelve tools and two ambient resources, and once connected the agent chains them on its own. They group cleanly by what the agent is trying to do, discover a market, read its book, summarise it, or check the pipeline.
- Discoverylist_categories · list_markets · list_historical_markets · get_market
- Order bookget_orderbook · get_snapshot · get_latest_snapshots · query_snapshots
- Aggregateget_market_summary · get_system_stats
- Exchangeget_exchange_orderbook · get_exchange_snapshots
- Discovery tools turn a vague ask into a concrete target, list_categories and the list tools surface what exists, and get_market resolves a friendly slug like btc-updown-5m to its 0x conditionId.
- Order-book tools are the workhorses, get_orderbook reads the live book, get_snapshot pulls a point in time, get_latest_snapshots grabs the last few, and query_snapshots pulls a window of history with full depth.
- Aggregate tools answer the quick questions, get_market_summary returns a seven-day envelope, and get_system_stats reports pipeline health.
- Exchange tools cover Hyperliquid perpetual books, the agent can call them on any tier, but the data follows the same Scale-and-above rules as the REST API.
- The two resources, markets://live and prices://latest, are ambient reads the agent can pull without spending a tool call, keeping it current on what is live and what prices just printed.
Why this beats asking the model to remember
A language model on its own answers a market question from a frozen, fuzzy memory of the internet. Connected over MCP, it retrieves the number from the live pipeline and the historical store instead, every figure in its answer traces back to a real tool result, not a recalled impression. That is what makes an agent’s market claims checkable rather than confident-sounding guesses.
The connection is the whole trick: once the agent can call the data, it stops describing markets from memory and starts reading them from the book.
Connect your agent
The AI Agents guide walks through installing and registering the server; the docs detail every tool and its parameters.
Frequently asked questions
Which clients can I connect to the MCP server?
Any MCP-compatible client, Claude Desktop and Claude Code are the common ones. You generate an API key, install the server, register it with the client so the agent can launch it, and the 12 tools and 2 resources become callable. The agent then chains them on its own to answer market questions.
Should I use stdio or HTTP transport?
Use stdio for a single local machine, Claude launches the server as a local process and talks to it over standard input and output, with no network exposure. Use HTTP when a shared or always-on instance needs to serve several clients. The tool surface is identical across both; only how the client reaches the server changes.
Do I need a paid plan to connect MCP?
No. MCP is included on every tier, including Free. All tiers connect the same 12 tools and 2 resources. The tools draw on your API key, so they share its rate limit and monthly credit allowance, paid tiers simply raise both for heavier agent workloads.
How do the tools keep the agent from making things up?
Because the agent retrieves rather than recalls. Each tool returns real values from the live pipeline or the historical store, and the two ambient resources keep it current on live markets and latest prices, so every figure in an answer traces back to an actual call rather than the model’s training memory.