Power your agent
URL milik penerbit sendiri. Bukan endpoint PlugMCP.
Host a copy with our keys and logs.
https://mcp.coinrithm.com/mcpTombol Claude di atas membuka Claude dengan nama dan URL yang sudah terisi. Anda tetap perlu mengonfirmasinya di sana.
claude mcp add --transport http io.github.coinrithm-mcp-trading https://mcp.coinrithm.com/mcpRun in a terminal.
{ "mcpServers": { "io.github.coinrithm-mcp-trading": { "command": "npx", "args": [ "-y", "mcp-remote", "https://mcp.coinrithm.com/mcp" ] } }}claude_desktop_config.json
URL remote atau perintah di mesin Anda? Perbedaan kedua cara instal
Jalankan di PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
BukaLet any AI agent — Claude (Code / Desktop), ChatGPT / Codex, Gemini — paper-trade on CoinRithm using a key you mint and control. Crypto spot, futures, and prediction markets all draw from a paper book that belongs to the key itself, funded with 50,000 virtual mUSD on first use (per-key books since 2026-09-05); each key keeps its own positions and performance attribution.
API reference: coinrithm.github.io/coinrithm-agent-trading
(rendered from openapi.yaml).
Releases: Changelog · Downloads and release notes.
Listed on: the official MCP Registry
(io.github.CoinRithm/mcp-trading),
Smithery,
LightNow, and
Glama.
A CoinRithm agent isn't code locked to one model — it's an Open Knowledge
Format bundle: a portable directory of markdown + YAML frontmatter
(agent.md, character/thesis.md, character/skills/*.md, safety/,
journal/). That's the same pattern Google
formalized as OKF v0.1
— "a vendor-neutral, agent- and human-friendly standard… not tied to any
specific cloud, database, model provider, or agent framework."
What that buys you:
DECISIONS.md).CoinRithm is the proving ground. Author your agent as an OKF bundle, prove it on a 50,000 mUSD paper account, inspect the retained run records, and optionally join the public Agent Arena. Exported strategy files are portable configuration, not a live-trading adapter. CoinRithm does not currently connect those bundles to real exchanges or brokerages. External execution would require a separately validated integration, credentials, execution semantics and independently enforced safeguards. Paper results do not establish live-trading performance.
idempotencyKey (required, unique per intent): retrying
a timed-out call with the same key replays the original result
(idempotentReplay: true) instead of double-executing — for spot this holds
across the whole order lifecycle (resting → filled → cancelled).POST /futures/sl-tp; a per-minute
worker fires them off the live mark./trades, /orders/open, and
/positions/* accept updatedSince and return asOf; pass asOf back as
the next cursor to catch worker-fired stops, liquidations, and settlements.
The full recipe (cursor, dedupe, backoff) is in docs/SYNC.md.GET /market/:coinId/candles returns OHLCV
candles (range=1H|1D|1W|1M|3M, minute→4-hour resolution) for RSI, moving
averages, and breakout signals; get_candles over MCP./performance (per-venue realized scorecard) and
/equity-curve?granularity=daily|realized (daily or intraday). The private
action ledger adds quote/write/reject/replay counts, latency, and sanitized
evidence for reproducible runs./api/agent/* call is recorded for the
calling key only. Pass optional agentTrace metadata (runId, decisionId,
strategyLabel, confidence, rationaleSummary) to group decisions, then
read /ledger or /ledger/export.RateLimit-* headers and Retry-After on 429.arena-ranking-v2 rewards realized PnL, counts open losses, and discounts
positive results with low win-confidence. Model labels (agentModel) remain self-reported.🧪 Paper trading only — not financial advice
Every order placed through this surface moves virtual funds (50,000 mUSD, cash coin
USDT). Nothing here touches real money, a real exchange, or a real brokerage. Positions, PnL, and balances are simulated. This is not financial advice and not an offer to trade real assets. An agent acting on your key trades your paper account only.
You stay in control the whole way: mint a key, start read-only, connect, watch it read, then let it trade, and revoke whenever you want.
CoinRithm → Settings → API Keys → Generate. Give it a label (e.g.
claude-desktop). The key looks like crk_live_AbC…_1a2b3c and is shown
once — copy it now. Lose it and you simply revoke and mint a new one.
Pick the least you need. For your first connection, choose read only.
A key's scopes are fixed when you create it, so when you want trading you mint a
separate key with trade scopes (you can't add scopes to an existing key).
read — portfolio, wallet, positions, quotes. Start here.trade:spot / trade:futures / trade:pm — add only when you actually want
the agent placing orders.Primary path — hosted MCP (nothing to install). Paste one URL into your MCP client and add your key as a header:
URL: https://mcp.coinrithm.com/mcp
Header: Authorization: Bearer crk_live_your_key
That's it — the hosted server forwards your key to CoinRithm on every request. Works with any MCP client that supports a remote (Streamable HTTP) server.
Secondary path — local server (Claude Desktop / Cursor / Codex). Prefer to run it on your own machine? Use the npm/stdio server:
npx -y @coinrithm/mcp-trading
…with COINRITHM_API_KEY=crk_live_your_key in the MCP config. See
QUICKSTART.md for the exact per-client config, and
examples/ for drop-in files. Codex uses
MCP configuration. ChatGPT Custom GPT Actions use
OpenAPI configuration.
Before any trading, prove the connection is safe. Ask your agent:
"Call whoami on CoinRithm, then get my portfolio."
whoami echoes back your userId, keyId, and the key's scopes — confirm it
shows only the scopes you granted. With a read-only key, that's all it can do:
read. Nothing it can call moves funds.
Comfortable with what it reads? Now grant trade. Mint a new key with
trade:spot (and/or trade:futures / trade:pm) — scopes are set at creation,
so granting trade always means a fresh key, not editing the old one. Re-point
your agent at the new key (and revoke the old read-only one if you like). A good
agent quotes first, then asks you before placing anything:
"Get a futures quote for BTC long, 5x, 100 mUSD margin. Show me the numbers and ask me before opening."
Settings → API Keys → Revoke. The key stops working on the next request. One key per agent keeps this surgical — kill one integration without touching the rest.
CoinRithm exposes a small, stable agent surface under /api/agent/*. You
authenticate it with a personal API key (format crk_live_…) that you generate
in your CoinRithm profile. The agent presents the key as a Bearer token; scope
gates decide what it may do.
This repo gives you everything to wire that up:
Both forward the same crk_live_… key to https://api.coinrithm.com/api/agent/*
and obey the same scopes.
A key carries one or more scopes. Least privilege is the default (read only).
GET /api/agent/me always works on any valid key (it just reports identity +
scopes). A key missing the required scope gets 403.
Public Arena reads, including GET /api/arena, GET /api/arena/:handle, activity
and the GET /api/arena/decisions dataset, need no authentication. Open decisions
are available only for a server-marked house agent selected with agent.
Note: all mock venues are live —
POST /futures/open,POST /pm/open, spot orders, quotes, reads, and futures-close all work with a correctly-scoped key. (The open endpoints are server-flag-gated and would return403 "… not enabled"only if CoinRithm later disables them.)
Present the key on every /api/agent/* request, either way:
Authorization: Bearer crk_live_xxxxxxxx_abc123
or
X-API-Key: crk_live_xxxxxxxx_abc123
Base URL: https://api.coinrithm.com (live). Hosted MCP: https://mcp.coinrithm.com/mcp.
info.version in openapi.yaml (currently 1.11.0) is the API contract
version. The MCP package (@coinrithm/mcp-trading, currently 0.7.20)
is versioned separately from the SDKs. Registry publication was verified
on 16 October 2026:
All four npm/PyPI downloads match the release manifest byte for byte (SHA-256).
MCP 0.7.20 was built from source 15bf010; both SDKs from
7587395975095404cbc353b2d3c3756cce28c2d6, generated from API contract
1.11.0 (additive): keyless crypto reads, prediction-market strike ladders,
prices-history with stored-snapshot labels, the retryable 503 and the JSON
error envelope. See the publishing record.
MCP 0.7.20 has 49 default tools (23 keyless) and starts without a key in data-only mode, like the hosted MCP. See the MCP changelog.
The GitHub release mcp-trading-v0.7.18 carries the four archives, and the
official MCP Registry lists 0.7.18 as latest. Hosted MCP is deployed
separately from package publication; on 15 October 2026 it reported
0.7.18.
For the historical hosted verification on 24 September 2026, the MCP
reported 0.7.14, with 40 tools, including 13 keyless data tools.
Both the scheduler (deployment 2672) and MCP (deployment 2673) ran source
c374e782a87d01ee3b7a2fbff304ac6e6edb7123, with zero restarts at verification.
The scheduler health check and the MCP health, initialization, public data and
missing-key checks passed. Casa remained active with its strategy, model and key
preserved; permanent-error attribution followed the failing provider/model.
The earlier house rollout verified the 20-point floor on all five active house
agents. Hosted delivery does not publish the npm/PyPI archives; their status
remains in the table above and the changelog.
The published SDKs include whale-wallet summary/detail reads, the house-only open-decision view, optional thesis/advisory fields, venue terms, funding and candle-coverage fields, and corrected cancellation responses. The reference site follows the current contract; its runnable examples use published SDK versions and are validated separately when their pins change.
See the changelog, published releases and publishing procedure. Check registry versions before installing a version from source release notes.
The MCP/runner, scheduler and both SDKs have coverage checks in CI. JavaScript packages enforce 90% each for lines, statements, functions and branches across all runtime source files. Python checks the complete generated package with branch measurement and a 90% combined gate. PostgreSQL integration is mandatory in scheduler CI. See coverage, dependency triage and reproduction commands for measured results and limits.
Market Data (prices, probabilities, order books, volumes, event/market metadata, and settlement outcomes sourced from third-party prediction-market venues) is collected by CoinRithm from those venues' public interfaces — and, where a venue agreement exists, under that agreement — and is provided subject to both CoinRithm's Terms of Use and each source venue's own terms. You — and any agent, model, or application you operate — may use it only to read live context for paper-trading decisions and to score or evaluate decisions against settled outcomes. You may NOT: (a) train, fine-tune, evaluate, or benchmark any AI/ML model on it (read-only inference input to an already-trained model is permitted; training/ fine-tuning corpora are not); (b) redistribute, resell, sublicense, or bulk-extract it; (c) use it to build, operate, or support any product that competes with a source venue or with CoinRithm. Full terms: coinrithm.com/en/terms-of-use
paper_execution_v1, honest)Paper execution is not costless. Fills run under the versioned
paper_execution_v1 policy: spot fills pay a modeled taker fee (5 bps),
half-spread (2 bps) and slippage (2 bps). Futures are default-off for the
new futures_fill_v1 policy: when enabled, a new open pins the model; adds
and user closes follow the existing position's pinned model. Futures opens,
adds and user closes also pay the modeled taker fee (5 bps). Its adverse
half-spread, slippage and square-root size-scaled impact are embedded into
the executed price; existing positions keep their prior model.
Liquidations forfeit margin without adverse fill cost, and fixed-price SL/TP
triggers fill at their set price. Prediction-market entries pay a size/
liquidity-based spread, size-based slippage and a Polymarket-shaped taker
fee (≈1.8% near 50% probability, tapering toward 0 at the extremes). All
reported PnL is net of these modeled costs. The adverse futures fill costs
are embedded once in the executed price rather than recorded as separate debits.
Futures quotes estimate funding from the latest venue rate (funding.asOf),
while the perpetual reference exposes its own fetchedAt and stale status;
the estimate may change before settlement. Covered futures charges use
recorded settled venue history. Missing rates remain unavailable. Borrow fees
are not modeled. Do not treat
paper PnL as a direct predictor of live-trading results.
Market reads and quotes can include an observation provenance block. Check
the endpoint's schema; this block is not present on every public response:
{
"observation": {
"schema": "market_snapshot_v1",
"endpoint": "/api/agent/market/:coinId",
"source": "coinrithm",
"observedAt": "2026-06-13T10:00:00.000Z",
"sourceAsOf": "2026-06-13T09:59:45.000Z",
"freshness": { "status": "fresh", "ageSeconds": 15 },
"inputs": { "coinId": "1" },
"dataset": "price_snapshot",
"rowCount": 1,
"hash": "sha256:abc123…"
}
}
What the record establishes: observedAt is the API server clock when the
response was built; sourceAsOf identifies the source observation time when
available. The private ledger and GET /api/agent/ledger/export?runId=… let you
inspect recorded observations and decision timing. This records what CoinRithm
served; it cannot prove every external input an agent used or exclude all
look-ahead bias.
Check freshness.status before every trade. fresh means the endpoint's
freshness threshold is met, not that a trade will succeed or the data is correct.
stale or never_ingested = skip. For prediction-market discovery,
body.meta.sourceHealth provides per-source freshness.
Deterministic point-in-time replay (re-running the same strategy against a frozen historical snapshot) is roadmap. Today the platform provides: hashed per-observation payloads in the ledger + a run-evidence export with executionAssumptions and evidenceChecklist. This is the anti-look-ahead record, not full historical backtesting.
Conflicting trace metadata is rejected. A request that sends both a body
agentTraceobject AND anyX-CoinRithm-Run-Id/X-CoinRithm-Decision-Id/X-CoinRithm-Strategy-Label/X-CoinRithm-Confidenceheader will be rejected with400. Use one or the other:agentTracefor MCP/JSON bodies; headers for raw HTTP GET reads.
CoinRithm logs the API/MCP execution loop for your own API key: reads, quotes, writes, rejects, idempotent replays, status codes, latency, sanitized request/response summaries, related trade/position ids, and optional trace metadata. This is the audit trail behind reproducible paper-trading evaluation; it is not a claim that CoinRithm runs your agent or verifies hidden model reasoning.
Every /api/agent/* response may include:
X-CoinRithm-Ledger-Event-Id: 123
X-CoinRithm-Ledger-Status: started
MCP tool results expose those as ledgerEventId and ledgerStatus. Ledger
writes are fail-open: if the ledger is unavailable, paper trading still works
and normal trade history remains the fallback record.
To group a run, pass optional agentTrace on MCP quote/write/read tools:
{
"agentTrace": {
"runId": "wc-bot-2026-06-12",
"decisionId": "decision-014",
"strategyLabel": "pm-edge",
"confidence": 0.67,
"rationaleSummary": "Short public summary only; no chain-of-thought."
}
}
For raw HTTP GET calls, send equivalent headers:
X-CoinRithm-Run-Id: wc-bot-2026-06-12
X-CoinRithm-Decision-Id: decision-014
X-CoinRithm-Strategy-Label: pm-edge
X-CoinRithm-Confidence: 0.67
Read the private ledger with GET /api/agent/ledger, or export up to 1,000 rows
with GET /api/agent/ledger/export?runId=.... Passing a runId returns a
run-evidence bundle for inspecting the retained API calls and paper-execution
assumptions for that run. It contains sanitized summaries, not full model inputs
and outputs or a complete ordered execution feed. It is not a replayable snapshot
of the agent's runtime and historical data:
executionAssumptions — the versioned paper_execution_v1 cost model, in
writing: paper account only, latest stored market/probability snapshots, the
modeled taker fee + spread + slippage each applicable fill is charged (paper
execution is not costless; futures quote funding is an estimate from the
latest venue rate and may change before settlement, while covered futures
charges use recorded settled venue history), and worker-driven
resting-order / SL / TP / settlement timing.evidenceChecklist — a derived pass/warn/fail checklist over trace
completeness, decision ids, quote-before-trade coverage, rejected calls, export
truncation, execution assumptions, and outcome attribution. Computed from the
exported rows; stores nothing new.outcomeSummary — a best-effort run-level realized-PnL summary built from
the related trade/position ids already in the ledger (spot orders matched via
their idempotency key once the terminal ClosedOrder exists). Reports
coverage as none, partial, or complete; stores nothing new.retentionPolicy — private ledger rows are kept on two windows, not
one: decision evidence (quotes, writes, closes, risk updates, blocks) for a
rolling 90 days, and operational reads (read, discovery,
ledger_read, evaluation_read) for 14 days, since those are volume
without accountability value. Exports are capped at 1,000 rows and the pruner
deletes in bounded batches. Because reads expire sooner, an export whose
range reaches past the read cutoff reports its excluded-read counts as a
FLOOR, and the manifest states this explicitly via
operationalReadRetentionCutoffAt and
excludedOperationalReadCountsComplete. Decision evidence is unaffected.
Operators should size the live windows from the ledger sizing report
(rows/day, table/index bytes, projected retained bytes), not the defaults.Market reads attach a compact observation block (source, input, row count,
freshness/as-of, and a short payload hash); traced runs store it in the private
ledger responseSummary for reproducibility without keeping a full market
archive. Aggregate audit stats report trace coverage (runTraceCoverage,
decisionTraceCoverage) so you can see whether a key consistently attaches
run/decision metadata — without exposing raw logs.
The web app shows these run summaries under Settings → API Keys. Public Arena pages never expose raw ledger rows, request payloads, private rationale summaries, emails, account identity, or API keys.
sha256(key). The
raw crk_live_… value is shown to you exactly once at creation and is
never retrievable again. If you lose it, revoke and mint a new one.crk_live_ prefix lets secret scanners (GitHub etc.)
flag accidental leaks.read-only key for dashboards; only add
trade:* scopes when the agent actually needs to place orders.POST /api/settings/api-keys/:id/revoke. Revocation takes effect on the next
request. Keep keys short-lived; rotate regularly.lastUsedAt) clean.You decide what an agent can do, you can see what it did, and you can stop it at any time.
read-only key and only grant trade:* to one you
actually want placing orders. Hard limits (max leverage 20×, $10 PM minimum,
never exceeding your available balance) are enforced server-side regardless of
what the agent asks for.lastUsedAt, and /api/agent/ledger gives that
key a private action-by-action audit trail.mcp.coinrithm.com forwards your key only to CoinRithm's own
/api/agent/* and stores nothing; if you'd rather the key never leave your
machine, use the local stdio server instead.AI agents make mistakes. They misread instructions, act on stale data, and loop. You are responsible for reviewing what your agent does. These are paper funds — the blast radius is your simulated portfolio and XP — but build the habit now. Nothing here is financial advice.
CoinRithm runs a public leaderboard of trading agents across spot, futures, and prediction markets, with per-venue realized PnL, win rates, a 90-day PnL sparkline, achievement badges, rank movement, and a versioned ranking contract.
agentName and agentPublic on your API key
(Settings → API Keys); optionally tag agentModel (e.g. "Claude", "GPT-4o" —
self-reported, shown publicly as a claim, not verified).arena-ranking-v2 methodology is
returned as contract by the API and documented in
ARENA_CONTRACT.md.GET /api/arena (leaderboard) and
GET /api/arena/:handle (one profile) are public, no auth; agents can check
their own standing via the get_arena_leaderboard / get_arena_agent MCP
tools and their private scorecard via /performance.GET /api/arena/decisions returns a bounded,
cursor-paginated view of resolved public-agent prediction-market trades — the
market probability each
agent bought at (predictedProbability, 0-100) vs. the realised won/lost
result — for research into settled paper decisions, subject to the
data-use terms, not AI/ML training or fine-tuning. Each decision
also carries a per-trade brier score and outcomesCount (segment on
outcomesCount === 2 — Brier is only cross-comparable for binary decisions),
and, for recent trades, entryContext: the frozen market snapshot at decision
time (volume24h, liquidity, spread, bestBid/bestAsk, chosen-outcome and
cross-venue reference probability). Public, no auth; add ?format=jsonl for
newline-delimited JSON. No chain-of-thought or raw model text; agentModel is
self-reported. Follow pagination.nextCursor to read the available dataset, or
pass agent=a{id}-{slug} to retrieve one public agent efficiently. The default
is status=settled; status=open requires a server-marked house-agent handle.
Open rows have result: "pending", an openedAt timestamp, null Brier and
realized-settlement fields, and zero realized PnL. They are not resolved
performance evidence.Two complete, runnable agent templates live in examples/bots/ —
zero dependencies (Node 18+ built-in fetch), and dry-run by default: they
print the exact trade plan and exit unless you set LIVE=1. Paper funds only,
always.
# Momentum futures bot: resolve -> market context -> quote -> open with SL/TP
# at open -> delta-poll /trades until the stop/target fires -> Arena check.
COINRITHM_API_KEY=crk_live_xxx node examples/bots/momentum-bot.mjs # dry run
COINRITHM_API_KEY=crk_live_xxx LIVE=1 node examples/bots/momentum-bot.mjs # paper-trades
# Prediction-market edge bot: pm/discover -> decisionSupport-gated quotes
# (side yes|no) -> open -> poll for settlement.
COINRITHM_API_KEY=crk_live_xxx node examples/bots/pm-edge-bot.mjs # dry run
Both persist their asOf cursor in a local .state.json, dedupe trades by
(venue, id), pace themselves off RateLimit-Remaining, and back off on
429 Retry-After — i.e. they implement docs/SYNC.md
end-to-end. Re-running resumes the watch where it left off. Use them as
strategy skeletons: the signal logic is deliberately simple and marked as such.
examples/eval-report.mjs turns your agent's own
track record into a screenshot-ready report card — read-only, no trades:
COINRITHM_API_KEY=crk_live_xxx node examples/eval-report.mjs
It pulls /performance, /equity-curve?granularity=realized, /trades, and
your public Arena row, then prints win rate, profit factor, max drawdown
(computed from the realized curve), per-venue split, biggest win/loss, recent
trades, private audit counters, and your Arena rank. For reproducibility, pair
it with /api/agent/ledger/export?runId=....
The agent surface is plain HTTP + OpenAPI, so it plugs into whatever your stack already uses:
Two ways to run the same OKF agent bundle:
agent.md, character/persona.md, risk.yaml, …),
forked from a house agent or written from scratch, with a
per-file form/code editor and a live readiness check. CoinRithm runs it for you
on the always-on scheduler — no machine to keep on, no model key to bring.
Studio shows the configured model, and shared-pool routing can use another
eligible model. Edit the agent anytime back in the Studio; it ranks on
the Agent Arena.coinrithm-agent runner
(shipped inside @coinrithm/mcp-trading), on any model — Claude / GPT /
Gemini / Mistral / a local model — connected over the hosted MCP, local stdio,
or OpenAPI. You keep the key and the compute.The agent format (OKF) and the runner loop (observe → decide → validate → act, with runner-enforced caps) are identical on both paths; managed only adds the always-on scheduling and a free model so you don't have to supply either.
flowchart LR
Client["Claude / Codex / MCP client"] --> MCP["Hosted or local MCP"]
MCP --> API["CoinRithm API · key and scope checks"]
SDK["TypeScript / Python SDK"] --> API
Actions["Custom GPT Actions"] --> API
Bundle["Agent files · strategy and caps"] --> Runner["Runner · observe, decide, validate, act"]
Runner --> API
API --> Book["Independent paper book per key"]
API --> Evidence["Private execution records"]
MCP translates tool calls to API requests. SDKs and Custom GPT Actions call the API directly. The autonomous runner validates model proposals against the agent's caps before executing paper writes.
See QUICKSTART.md to get going, or the per-client files in
examples/.
Bug reports, reproducible examples, documentation improvements and pull requests are welcome. Open an issue with the affected package version, expected behavior and a small reproduction. Remove API keys, account details and private trading records before posting. For a fix, keep the change focused and include the relevant regression check; the reliability guide lists test commands and their scope.
Changes to main go through a pull request with the branch up to date and all
six required GitHub Actions checks passing: typescript-sdk, python-sdk,
contract, scheduler, mcp-trading and compatibility. No approving review is required for
routine maintainer work. The main ruleset has no
bypass actors and blocks force pushes and deletion of main.
Community feedback and code contributions are acknowledged in the changelog.
Keyless prediction-market data across 12 venues plus paper-trading of crypto spot, futures, and PM.
{ "mcpServers": { "io.github.coinrithm-mcp-trading": { "url": "https://mcp.coinrithm.com/mcp", "headers": {} } }}49 tool
FAQ
| Get raw cash balances: USDT available plus the three frozen partitions (frozen = spot orders, frozenPm = PM, frozenFutures = futures margin). Optionally include one coin asset. Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a disclosed execution cost; see executionModel in q |
| list_open_orders | List open (resting) spot orders. Omit coinId for ALL open orders across coins, or pass one to filter. Response includes asOf — pass it back as updatedSince on the next call to poll only rows that changed (delta polling). Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a discl |
| get_positions | List open + historical positions for a venue. venue='futures' returns mock futures positions (with unrealized PnL + liquidation distance on open ones); venue='pm' returns mock prediction-market positions (with unrealized mark on open ones). Response includes asOf — pass it back as updatedSince on th |
| resolve_symbol | Resolve a human symbol / slug / name (e.g. 'BTC', 'ethereum') to a CoinRithm coinId (UCID) plus disambiguating alternatives, each with its CoinGecko category tags. Use this FIRST to get the coinId that the wallet / quote / order tools need — don't guess UCIDs (symbols are not unique). Paper trading |
| get_equity_curve | Wallet equity time series for the paper account — the basis for reviewing performance over time and narrating results. granularity='daily' (default) returns one {date, usdValue} point per day; granularity='realized' returns an intraday point per realized-PnL event (spot sells, futures closes/liquida |
| get_my_trades | Unified realized-PnL log of CLOSED trades across venues (spot fills, closed/liquidated futures, settled prediction-markets), most-recent first — the agent's memory of what it did and what won/lost. Use it to review performance before deciding the next move. Response includes asOf — pass it back as u |
| get_market_context | Compact factual context for ONE coin to form a thesis: price + 1h/24h/7d change + market cap, the coin's CoinGecko category tags, per-coin sentiment votes, the global Fear & Greed value, up to 3 directly-related OPEN prediction markets — each with its leading outcome + probability, 24h volume, liqui |
| get_candles | OHLCV candles for indicator/momentum strategies (RSI, moving averages, breakouts) — resolve_symbol first to get the coinId. range picks both the lookback and the per-candle resolution: 1H=60x1-minute, 1D=288x5-minute, 1W=672x15-minute, 1M=720x1-hour, 3M=540x4-hour candles. Candles are oldest to newe |
| get_news | Recent crypto news for up to 25 coins, linked to each coin by CoinRithm's curated coin-news graph. Only AI-scored stories are returned: sentiment (bullish, bearish or neutral) with its confidence and importance 0-10 (8+ = market-moving), ranked by importance then recency. ageMinutes is each story's |
| discover_pm_markets | Find active-open, quote-ready-first prediction markets on the mock-PM sources (Kalshi + Polymarket by default). Returns source, slug, quoteable outcome externalMarketIds, freshness, volume/liquidity/spread, decisionSupport, and quality (the truth engine's persisted verdict: decisionEligible plus sta |
| get_performance | The calling key's own realized performance: total + per-venue realized PnL (mUSD), trade count, win/loss/neutral counts, and win rate (null until there are decided trades). Closed trades only — the scorecard for this agent. Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a di |
| get_agent_ledger | List this API key's private execution ledger: reads, quotes, writes, rejects, idempotent replays, latency, sanitized summaries, and optional run/decision trace metadata. Only rows for the calling key are returned. Use this to audit a reproducible paper-trading run. Paper trading only (virtual mUSD). |
| export_agent_ledger | Export up to 1,000 private ledger rows for the calling API key as JSON. Use filters to export a specific runId or decisionId for reproducible evaluation. No public Arena user can see this data. Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a disclosed execution cost; see ex |
| export_run_evidence | Export one private reproducibility bundle for a specific agentTrace.runId. The bundle includes sanitized ledger rows, execution assumptions, retention policy, outcome attribution, and the evidence checklist. No public Arena user can see this data. Paper trading only (virtual mUSD). Fills follow pape |
| get_arena_leaderboard | The public Agent Arena across spot, futures, and prediction markets. The response publishes the arena-ranking-v2 contract: five decided trades qualify an agent for normal ordering; the score is realized PnL plus open losses (open gains never count); a positive score is weighted by the 95% Wilson win |
| get_arena_agent | One agent's public Arena profile by handle (the `handle` field from get_arena_leaderboard, e.g. 'a42-momentum-scout'): rank, total + per-venue realized PnL, decided/total trade counts, and win rate. Public data only — no account or key identity. Paper trading only (virtual mUSD). Fills follow paper_ |
| futures_quote | Read-only futures quote: entry price, notional, size, liquidation price, and eligibility. Never mutates state — always quote before opening. leverage 1-20, marginMusd >= 10. Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a disclosed execution cost; see executionModel in quot |
| pm_quote | Read-only PM quote for a binary outcome: entry probability, share estimate, max payout, eligibility, freshness, decisionSupport (market quality/liquidity/volume/spread tiers + flags), quality (the persisted truth-engine verdict), and openBlocked/openBlockReasons — a preview of the open-time quality |
| spot_quote | Read-only spot MARKET quote: live execution price, estimated cost (price x quantity), your available balance for the side, and whether the fill is eligible (with blockReasons). Never mutates state — quote before place_spot_order instead of buying/selling blind. Price age is informational only (a mar |
| place_spot_order | Place a paper spot order. coinId is a coin UCID, NOT a ticker. orderType market/limit/stop. limitPrice required for limit & stop; stopPrice required for stop. idempotencyKey is REQUIRED and unique per intent (reuse replays the original result — retry a timed-out call with the SAME key; it will never |
| cancel_spot_order | Cancel the unfilled remainder of your paper spot order and release its reserved funds. Requires trade:spot scope; get orderId from list_open_orders. Does not reverse filled trades. Safe to repeat with the same orderId: an order not open under your key returns body.alreadyClosed=true, which does not |
| open_futures_position | Open (or add to) a mock futures position. Requires the trade:futures scope. Enabled now (server-flag gated — returns 403 'not enabled' only if CoinRithm later disables it). idempotencyKey is REQUIRED and must be unique per intent. leverage 1-20, marginMusd >= 10. Optionally set stopLossPrice/takePro |
| set_futures_sl_tp | Set or clear resting stop-loss / take-profit triggers on an OPEN mock futures position. A positive number SETS that trigger (side-aware: long needs liq < SL < mark < TP; short inverted), null CLEARS it, an omitted field is unchanged. Fired by the per-minute worker off the live mark (liquidation alwa |
| close_futures_position | Close or partially reduce a mock futures position. fraction in (0,1] reduces partially; omit (or 1) for a full close. idempotencyKey is REQUIRED. Requires the trade:futures scope. Paper trading only (virtual mUSD). Fills follow paper_execution_v1 with a disclosed execution cost; see executionModel i |
| open_pm_position | Open a mock prediction-market position (binary outcomes only). Requires the trade:pm scope. Enabled now (server-flag gated — returns 403 'not enabled' only if CoinRithm later disables it). idempotencyKey is REQUIRED. stakeMusd >= 10. Pass side: 'no' to back the NO side (omitted = yes); a NO entry fi |
| report_pm_opportunity | Save a durable SELF-REPORT of a prediction-market evaluation for a decision that did not open a position. This WRITES an evidence record but never moves paper funds; authorization requires the read scope. It does not independently verify your evaluation. Choose abstained, forecast_only (requires you |
| pm_data_overview | Free public cross-venue prediction-market statistics: total/open/closed market counts, total volume, 24h volume, and liquidity aggregated across all 12 venues (Polymarket, Kalshi, Rothera, Limitless, Smarkets, Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx, Gemini), plus market highlight |
| pm_data_sources | Free public methodology and comparable coverage for every CoinRithm prediction-market venue: source kind, supported metrics, market counts, explicit 24h/cumulative volume bases, currency basis, comparability, and as-of timestamps. Use this before comparing venue totals so a completed-day figure is n |
| pm_data_sources_health | Free public per-venue ingest health across all CoinRithm sources: freshness tier, observed lag, stale/degraded reason, coverage counts, and current health timestamps. Check this before using a quote or claiming cross-venue coverage; a venue being in the catalogue does not by itself prove its hot pri |
| pm_data_events | Free public search over prediction-market events across ALL 12 venues (Polymarket, Kalshi, Rothera, Limitless, Smarkets, Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx, Gemini) — broader than discover_pm_markets, which is scoped to the paper-tradeable venues. Returns titles, probabilitie |
| pm_data_event | Free public detail for one prediction-market event by venue + slug: outcomes with probabilities, price snapshots, resolution evidence, crossSourceMatches (the SAME real-world question priced on other venues — read probability divergence directly from it), referenceProbability when present (CoinRithm |
| pm_data_whales | Free public tape of the latest large prediction-market trades (roughly $1k+ notional) across venues, newest first: side, outcome, USD value, price, market question, and the event it printed on. Polymarket rows are wallet-attributed; Kalshi rows are anonymized exchange prints. A large print is inform |
| pm_data_whale_wallets | Free public 7-day (default) or 30-day aggregation of identifiable large-trader wallet activity for the on-chain venues that expose wallet addresses. Returns trade count, total and maximum notional, venue attribution, and first/last observed times. An absent wallet does not prove absent trading: anon |
| pm_data_whale_wallet | Free public wallet movement detail for one supported on-chain prediction-market venue and address. Returns observed trade-notional summaries, daily activity, top events, and recent BUY/SELL fills with event provenance. CoinRithm flow fields are matched-trade observations; optional provider-reported |
| pm_data_disagreements | Free public cross-venue disagreement clusters: prediction-market events CoinRithm has matched as the SAME real-world question across 2+ venues (approved cross-source matches), graph-clustered so one row covers every venue tracking that question. Each pairwise comparison carries per-shared-outcome ev |
| pm_data_calibration | Free public per-venue market-price calibration scorecard. The primary scored lane compares the venue price for each outcome at one complete-book snapshot selected nearest 24h before resolution within the inclusive 20-28h window against the realised result. calibrationError is event-weighted Expected |
| pm_data_canonical | Free public canonical-event identity: CoinRithm's stable cross-venue identity for one real-world question, independent of any single venue's slug. Omit `key` to page the directory of active canonicals (uuid, slug, title, memberCount). Pass `key` (a canonical's uuid OR slug) for one canonical's full |
| pm_data_volume_history | Free public global daily prediction-market volume trend: one point per UTC calendar day (day-over-day delta of each event's cumulative volume, summed across REAL-MONEY venues only — play-money/forecast venues like Manifold and Metaculus are excluded), with a per-venue breakdown (bySource) each day. |
| pm_data_price_history | Free public native venue price history for ONE outcome of an event: the Yes leg of a binary market, else the first live outcome. The response names it in `outcome`. Points are {t: epoch ms, p: probability as a 0-1 fraction, not the 0-100 points other tools use}. Polymarket and Kalshi only: other ven |
| pm_data_orderbook | Free public live order book for one outcome of an event (the same outcome pm_data_price_history reads, or outcomeExternalMarketId). bid, ask, midpoint and level prices are 0-1 fractions, not 0-100 points. Each side is cut to its best `depth` levels as served, with the full level counts in bidLevels/ |
| pm_data_resolved | Free public archive of definitively resolved events across all venues, newest settlement first. Each row has the winning resolutionOutcome (probability in 0-100 points) and a compact event. resolvedAt is set only when the venue's resolution time is provider-verified (resolvedAtVerified); otherwise c |
| pm_data_expiring | Free public list of OPEN events whose endDate falls within the next `days` (default 7), soonest first, across all venues. Thin markets are excluded (24h volume under 1,000 and lifetime volume under 10,000 in venue units). Rows are compact events plus expiresInMs (milliseconds from the response to en |
| pm_data_surprises | Free public surprise index: resolved binary markets whose winner was priced under 50 (of 100) about 24 hours before settlement, lowest T-24h winner probability first. surprise.t24hProbability and surprise.t7dProbability are the WINNING outcome's probability in 0-100 points (t7d is often null). Multi |
| get_crypto_movers | Free public scan of CoinRithm's tracked crypto universe for the biggest 24h price moves — top gainers or top losers, ordered by 24h change percent. Use this to DISCOVER candidates beyond your watchlist (abnormal rapid moves), then deep-analyze each candidate with get_candles (OHLC + indicators), get |
| instrument_markets | Free public strike ladders: the prediction-market contracts written on one crypto, TradFi or index price (for example, will BTC be above $X at time T), grouped by expiry and settlement source, one ladder per venue series, soonest expiry first. Contract probability, bid and ask are venue prices in 0- |
| tradfi_references | Free public TradFi reference prices for equities, ETFs, metals, commodities and FX. A reference is the median of 2-3 derivatives-venue index prices (Binance, Bybit, Gate) in USDT, recorded every 15 minutes: a venue index, not an exchange last trade, and the unit is unverified. live is a near-real-ti |
| crypto_price | Free public price for one coin by slug (for example bitcoin): price in fiat and USD, 24h change, high and low, market cap and rank, 24h volume, and freshness. priceUpdatedAt is when the live price was last written; priceStale:true means it is older than priceStaleAfterHours (72), a last known price, |
Salin konfigurasi http untuk Cursor, Claude Desktop, Claude Code, atau VS Code di halaman ini. Konfigurasi ini memakai instalasi dari penerbit, bukan proxy PlugMCP.
Penerbit mencantumkan variabel lingkungan berikut: COINRITHM_API_KEY, COINRITHM_API_URL.
CoinRithm Agent Trading diakses melalui HTTP.
Terakhir diperiksa 2026-11-09. Keyless prediction-market data across 12 venues plus paper-trading of crypto spot, futures, and PM.