rivomarkets
TradersLive dataStrategiesDevelopersLearnPricing
Launch terminal

MCP server

Give your AI the whole prediction market tape.

A remote MCP server over Polymarket and Kalshi whale data. Claude, ChatGPT or Cursor can rank traders, backtest a rule against settled markets, check it out of sample, read the live feed, and, if you allow it, trade from your own account. Nothing to install.

Get an API keySetup and tool reference

Included with the $15/month subscription. 120 requests per minute per key.

Tools
23

Research, traders, markets, strategies, account and trading.

Read-only tools
17

What a default read key is offered. Nothing here changes state.

Venues
2

Polymarket and Kalshi, one history, one set of tools.

Quota
120/min

Per key, shared with the REST API. Fan-out tools charged per variant.

endpoint
https://api.rivo.markets/mcp
Claude Code
claude mcp add --transport http rivo-markets https://api.rivo.markets/mcp \
  --header "Authorization: Bearer rivo_live_..."
Cursor, Claude Desktop, JSON-config clients
{
  "mcpServers": {
    "rivo": {
      "url": "https://api.rivo.markets/mcp",
      "headers": { "Authorization": "Bearer rivo_live_..." }
    }
  }
}

Create the key in Settings under Developer. It is shown once and stored as a hash. Start with the read scope; add write or trade later if you want the assistant to save strategies or place orders.

What a session looks like

This is the loop the server is built for: describe the data, propose a rule, score it, validate it out of sample, then decide. The transcript below is the same one on the homepage.

claude rivo mcp

> Find me a rule that beat the market on longshots.

→ describe_universe({})

57,412 trades · 90 days · 53,208 settled · 5 categories · 2 platforms

→ sweep({ field: "priceMax", values: [0.10, 0.15, 0.20, 0.30] })

0.10: -44% 0.15: +45% 0.20: +60% 0.30: +28%

→ backtest({ criteria: { priceMax: 0.2, minAmountUsd: 10000 }, holdout: true })

in-sample +58% · out-of-sample +58% · holds: true

→ save_strategy({ name: "Longshot Hunters", backfill: true })

saved · 449 trades claimed · daily digest on

Longshots under 20¢ with over $10K behind them returned +58% across 449 settled trades, and held on data they were never tuned on. Saved as "Longshot Hunters". New matches will appear in the daily digest.

Real numbers from a real run. Paper results at $100 a trade.
  1. 01

    Describe the universe

    describe_universe returns the categories, date coverage, settled counts, and the price and size distributions. Calling it first is what stops a model writing a rule that matches nothing.
  2. 02

    Score, then hold out

    backtest scores a rule against settled markets and saves nothing. With holdout on it scores the earlier two-thirds of the window and validates on the final third. sweep varies one threshold across up to twenty values; compare scores several rules side by side.
  3. 03

    Deploy or act

    save_strategy turns a rule that held into a live paper strategy that keeps claiming matches. set_follow and set_autopilot manage traders. place_order buys the same side of a market you are looking at, dry run by default.

Every tool, and the scope it needs

Tools are grouped by what they touch. A key's scopes decide which tools are registered at all: a model that cannot see a tool cannot loop retrying it.

A key only ever sees the tools its scopes allow. A read key is offered the read tools; write adds account state; trade adds the two tools that move money.
ToolGroupWhat it doesScope
describe_universeResearchWhat data exists to test against: categories and their trade counts, date coverage, settled counts, and the price and size distributions.read
backtestResearchScore a rule against markets that already resolved. Saves nothing, so it is safe to call repeatedly while exploring.read
sweepResearchScore one rule across a range of values for a single numeric field, in one call.read
compareResearchScore several unrelated rules side by side in one call, each with a label.read
breakdownResearchSplit one rule's results by category, platform, month or price band, to see where it works and where it does not.read
query_whale_eventsResearchThe individual trades a rule matches, for inspecting specifics rather than aggregates.read
list_tradersTradersThe tracked traders, ranked. copyScore and copyGrade are our own quality measure and a better default than raw profit.read
get_traderTradersOne trader's profile and, by default, what copying them at a flat stake would have returned over the last 90 days.read
compare_tradersTradersReplay two to ten traders at the same stake and window, side by side.read
set_followTradersFollow a trader, unfollow them, or turn their alerts on and off.write
search_marketsMarketsFind recently active markets by name, with the whale trades behind each.read
get_live_feedMarketsThe live tape, newest first. Lane whale is large trades regardless of who placed them; lane tracked is any trade by an identified trader regardless of size.read
get_marketMarketsOne market: prices, spread, liquidity, open interest, close time, rules, and the recent trades in it.read
save_strategyStrategiesTurn a rule into a live strategy on the account. It keeps claiming matching trades as they happen and alerts you.write
list_strategiesStrategiesThe account's strategies with their current record.read
get_performanceStrategiesFull performance for one saved strategy: settled record, realized and open PnL, and the return curve.read
get_portfolioAccountWhat you hold, what you have ordered, your standing exit rules, and whether autopilot can actually run.read
get_copy_logAccountThe autopilot audit log, including the copies that did not happen, each with a skipReason.read
get_alertsAccountFollowed-trader trades and strategy rollups, newest first.read
set_exit_ruleTradingPut a standing stop-loss, take-profit or trailing stop on a position, or cancel one.write
set_autopilotTradingTurn autopilot on, pause it, or turn it off for one followed trader.write
place_orderTradingBuy the same side of the same market as an observed trade.trade
sell_positionTradingSell a held position, all of it or part.trade
read

Research, traders, markets, portfolio and logs. The default for a new key. Changes nothing.

write

Account state: follows, exit rules, saved strategies, paper Autopilot, and pausing live Autopilot.

trade

Moves money: place_order, sell_position, and switching Autopilot from paper to live. Also carries a per-key daily spend cap.

Prompts and resources

Three prompts encode the order the tools want to be called in, which is where most mistakes live. find_a_trader_to_copy goes leaderboard to shortlist to flat-stake replay and ends with a recommendation that names its weak points. build_a_rule explores criteria, validates out of sample, and stops if the rule does not hold. audit_my_autopilot reads the copy log and splits what Autopilot skipped into what you can fix and what you cannot. Two resources, rivo://universe and rivo://portfolio, expose the data coverage and your positions and readiness without spending a tool call.

Guardrails on money

  • Three affirmations to go live. Turning Autopilot live needs the trade scope on the key, paper: false, and confirmLive: truein the same call. Paper is the default and spends nothing.
  • Dry run by default. place_order and sell_position return the quote unless dryRun: false is passed deliberately.
  • Idempotent orders. MCP cannot carry an Idempotency-Key header, so one is derived per call and bucketed to ten minutes. A timed-out retry does not buy twice; a deliberate repeat later still goes through.
  • Spend cap. Each trade-scoped key carries a daily spend ceiling that fails closed. Per-follow and per-day Autopilot caps apply on top.
  • Readiness before guessing. get_portfolio with the readiness section says exactly why a copy cannot run: wallet not ready, account not connected, spend cap reached, missing scope. Every tool description that touches Autopilot points there first.
  • Create-only strategies. Strategies cannot be edited or deleted through the server, so a confused agent cannot destroy a history you built.

Errors and quota

Every error carries a stable code so an agent can branch on it while the prose changes underneath. The quota is 120 requests per minute per key over a fixed window, shared with REST. sweep is charged per value, compare per rule, compare_traders per trader, and each extra include section on get_trader costs one more. On a 429, wait for the retry-after value rather than looping. See the rate limits and errors pages.

The same thing over REST

Each tool is backed by the same handler as a /v1 endpoint, so anything an assistant can do you can script. The request below is what backtest sends.

REST equivalent
curl https://api.rivo.markets/v1/backtest \
  -H "Authorization: Bearer rivo_live_..." \
  -H "Content-Type: application/json" \
  -d '{"criteria":{"platforms":["kalshi"],"priceMin":0.05,"priceMax":0.25,"minAmountUsd":10000},"holdout":true}'

The developer docs carry the full parameter and response reference for every endpoint, generated from the same definitions the server uses, with samples in curl, Python and TypeScript. A public SSE stream at /v1/stream delivers the live tape to your own code, and outbound webhooks deliver it to a URL you register.

Things people ask it to do

Copy any of these into a client that has the server connected.

  • Traders

    Shortlist Kalshi traders worth copying

    "Rank Kalshi traders by copy score, take the top ten, replay each at a flat $50 stake over 90 days, and tell me which three hold up and what their worst month looked like."
  • Rules

    Test a longshot rule out of sample

    "Backtest Polymarket buys between 5 and 20 cents of at least $10,000 with holdout on. If it holds, sweep the price ceiling from 10 to 30 cents and show me where the return peaks."
  • Markets

    Explain what just moved

    "Read the live whale feed for the last hour, group by market, and for the top three tell me who was buying, at what price, and whether other tracked traders were on the same side."
  • Breakdown

    Find where a rule works

    "Break down my saved strategy by category and by month. Which segments carry the return, and does it still hold if I drop sports?"
  • Autopilot

    Audit why a copy did not happen

    "Read my copy log for this week, list every skip with its reason, and tell me which ones I can fix by changing my caps versus which were market conditions."
  • Trading

    Quote before you act

    "Dry-run a $200 buy on the same side as the largest trade in the feed right now and show me the fill price and slippage against the whale's entry."

Frequently asked questions

What is a prediction market MCP server?

An MCP (Model Context Protocol) server exposes tools that an AI assistant can call. Rivo's server exposes its whale data, trader records, backtester and trading surface as tools, so Claude, ChatGPT, Cursor or any MCP client can query Polymarket and Kalshi history, test rules against settled markets, and act on the account behind the key.

Is it local or remote?

Remote, over HTTP. There is nothing to install or run. Add the endpoint to your client with your API key as a bearer header and the tools appear. It runs alongside the main Rivo API on the same auth and the same quota.

Which clients work?

Anything that speaks MCP over HTTP with custom headers: Claude Code, Claude Desktop and claude.ai connectors, Cursor, ChatGPT connectors, and SDK-based agents. The docs carry the exact config for Claude Code and JSON-config clients.

Can an AI spend my money through this?

Only if you let it, three times over. The key needs the trade scope, which you grant when creating it. Every order defaults to a dry run that returns the quote without filling. And turning Autopilot live needs both paper set to false and an explicit confirmLive flag. A read key cannot even see the trading tools.

What does it cost?

It is included in the $15/month subscription. The quota is 120 requests per minute per key, shared between the REST API and the MCP server. Sweeps and comparisons are charged per variant.

How is the backtest return computed?

The way prediction market contracts settle: a winning contract pays $1 and a losing one pays $0. A $100 stake at 20 cents returns $400 profit on a win and loses $100 on a loss. Stake defaults to a flat $100 per trade so two rules are comparable. Results are paper, gross of fees. The methodology page has every formula.

Is there a plain REST API too?

Yes. Every MCP tool is backed by the same handler as a REST endpoint under /v1, with the same keys and quota. Use REST when you want to script it yourself; use MCP when you want an assistant to drive.

Connect it in a minute.

Create a read key, add the endpoint to your client, ask it to describe the universe. Included with the $15/month subscription.

Get access

Related

  • Strategy backtesting
    Score a rule against resolved Polymarket and Kalshi markets before you follow it.
  • Kalshi whale tracker
    Live large trades on Kalshi with the trader, market, side, size, and entry price attached.
  • Tracked traders
    Ranked traders across both venues with the records we observed ourselves.
  • Methodology
    How Rivo records trades, settles markets, computes paper PnL, grades traders and validates rules.
rivomarkets

The premier prediction market trading setup. Track the sharpest traders on Polymarket and Kalshi, backtest your rules against settled markets, then copy or autopilot them from one terminal.

Launch terminal

Product

  • Alerts
  • Strategies
  • Autopilot
  • Pricing

Trackers

  • Kalshi whale tracker
  • Kalshi insider trading
  • Polymarket whale tracker
  • Polymarket insider trading
  • Polymarket smart money

Live data

  • Ranked traders
  • Biggest wins
  • Biggest losses
  • Learn
  • Research
  • Methodology
  • Compare tools
  • About Rivo

Developers

  • API overview
  • Documentation
  • MCP server

RivoMarkets is an information and trading interface for third-party prediction markets. Nothing on this site is financial, investment, legal, tax, or gambling advice. Trading involves risk of loss.

TermsPrivacyDisclaimer© 2026 RivoMarkets