How to Build Your Own Crypto Trading Agent (No Backend Required): MCP + API Key Walkthrough

Want to build a crypto trading agent without standing up a server, a database, or any infrastructure at all?

You can. CoinRithm gives you a paper-trading API, an MCP server, and a self-host runner so a language model — ChatGPT, Claude, or any MCP-capable agent — can read live market data and place simulated trades using a single API key. There is no backend to write: the trading logic, the risk caps, the order execution, and the leaderboard already exist. You bring a key and (optionally) a model, and wire them together.

This is a real, step-by-step build guide. By the end you will have: a CoinRithm API key with the right scopes, a working connection through either ChatGPT Custom Actions or Claude via MCP, hard risk caps in place, a dry-run confirmed, your agent trading on paper, and an opt-in entry on the public Agent Arena.

Ground truth before you build:

• All trading on CoinRithm is simulated with virtual funds (a 50,000 mUSD paper account). No real money, no exchange, no wallet, no blockchain.
• CoinRithm is not a broker or exchange. This is a rehearsal sandbox for testing whether an agent's strategy survives autonomous execution against real market data.
• Agents authenticate with a user-issued API key (crk_live_…) from your profile. You control what each key can do via scopes.
• Paper results do not predict real-trading performance. Treat them as evidence of decision quality, not a P&L promise.

If you want the higher-level "what is agentic trading" overview first, read How to Let an AI Agent Paper Trade Crypto. This guide is the hands-on build.

TL;DR

• Mint a crk_live_… key at Profile → API Keys. Start with the read scope only.
• ChatGPT path: paste https://coinrithm.com/openapi.yaml into a Custom GPT → Actions, set Bearer auth. Zero code.
• Claude/MCP path: add https://mcp.coinrithm.com/mcp as a remote MCP server with a Bearer key, or run npx -y @coinrithm/mcp-trading locally as a stdio server.
• Want a true autonomous loop? Use the coinrithm-agent runner (shipped in the same package). It is dry-run by default, enforces your caps in the runner (not the model), and has a kill switch.
• Confirm a read-only call, add trade scopes, run a dry-run, then go live on paper. Opt into the Arena to be ranked by realized PnL.

What "No Backend Required" Actually Means

A traditional trading bot needs a server to hold credentials, a process to poll prices, code to size and place orders, persistence for state, and risk logic to stop it doing something stupid. That is a lot of backend.

CoinRithm collapses all of that into existing surfaces:

• The API (api.coinrithm.com) handles market data, order placement, position state, and the paper wallet.
• The MCP server (mcp.coinrithm.com) exposes those endpoints as tool calls any MCP client can use — so the model talks to the API in its own native "tool use" language.
• The runner (coinrithm-agent) gives you the observe → decide → validate → act loop, the risk caps, idempotency, and the kill switch — so you do not write a control loop or a risk engine yourself.

You write a persona and a strategy in plain language plus a few numeric caps. Everything that would normally be backend is provided. That is the "no backend" claim, and it is honest: the only thing you genuinely cannot skip is the strategy itself.

There are three ways to run, from least to most code:

Pick one. You can graduate from the first to the third later — the same API key works across all of them.

Prerequisites

You need very little:

• A CoinRithm account (free). Sign up if you do not have one.
• One of: a ChatGPT account that supports Custom GPTs, an MCP-capable client (Claude Desktop, Cursor, Codex, or any MCP host), or Node.js 18+ for the runner path.
• For the runner's autonomous loop only: a model API key of your own (Anthropic, OpenAI, or Groq). The ChatGPT and Claude-client paths use the model you are already in.

No server. No database. No deploy step.

Step 1 — Get an API Key (and the Right Scopes)

Everything starts with the key. It is a bearer credential — anyone who holds it can act as you on the paper API.

1. Sign in to CoinRithm.
2. Go to Profile → API Keys.
3. Click Create Key.
4. Name it clearly, e.g. build-agent — read-only.
5. Set the scope to read only for now.
6. Copy the key. It starts with crk_live_. You will not see it again, so store it where you keep secrets.

Understand the scopes

The API uses four scopes. Grant only what the agent needs:

Start read-only. You can add trade scopes later — or, safer, create a separate trade-enabled key for the agent and keep the read-only key for exploration. One key per agent makes the private ledger easy to audit.

Key safety, non-negotiable: never commit a crk_live_… key to a public repo, never paste it into a shared chat, and revoke + re-issue immediately if it leaks (Profile → API Keys → Revoke, no cooldown). The worst case is still only your mock balance — but treat the key as a real secret out of habit.

Step 2 — Choose Your Path: ChatGPT Actions vs Claude/MCP

Both paths are honest, supported, and take about ten minutes. The difference is the client and the wiring format.

• ChatGPT Custom Actions reads an OpenAPI spec. You paste a URL, set auth, done. Conversational and human-supervised by nature.
• MCP (Model Context Protocol) is the open tool-calling standard Claude, Cursor, Codex, and many frameworks speak. You add a server, the client fetches the tool list automatically.

Pick by what you already use. The next two steps cover each.

Path A — ChatGPT Custom GPT Actions

1. In ChatGPT, go to Explore GPTs → Create.
2. Name it (e.g. "CoinRithm Trader").
3. Add a system prompt that imposes discipline (use the persona template below).
4. Open Configure → Actions → Create new action.
5. In Schema, enter the OpenAPI URL:

   https://coinrithm.com/openapi.yaml
   

   ChatGPT loads the spec and lists the available operations (whoami, market context, candles, quotes, spot/futures/PM orders, and so on).
6. Under Authentication, choose API Key, set Auth Type to Bearer, and paste your crk_live_… key.

That is the entire setup. Your GPT can now call CoinRithm tools inside a conversation. See the Agentic Trading page for the connect UI.

Path B — Claude or Any MCP Agent

Option B1 — Hosted remote MCP (simplest). If your client supports remote MCP server URLs, add:

Server URL: https://mcp.coinrithm.com/mcp
Auth:       Bearer <your crk_live_ key>

The hosted server holds no key of its own — each request carries its own crk_live_… in the Authorization header and the server forwards exactly that key upstream. Read more on the MCP Trading Server page.

Option B2 — Local stdio server (for Claude Desktop, Cursor, Codex). Run the npm package as a local stdio process:

COINRITHM_API_KEY=crk_live_… npx -y @coinrithm/mcp-trading

This starts the coinrithm-mcp server and exposes the full tool set over stdio. A typical MCP host config looks like:

{
  "mcpServers": {
    "coinrithm": {
      "command": "npx",
      "args": ["-y", "@coinrithm/mcp-trading"],
      "env": { "COINRITHM_API_KEY": "crk_live_…" }
    }
  }
}

Note the package ships two binaries: coinrithm-mcp (the server you just wired) and coinrithm-agent (the self-host runner, covered in Step 6).

Verify the connection (do this before anything else)

Ask your agent a read-only question, for example:

"What is the current Bitcoin price, and what prediction markets are open on Bitcoin right now?"

A working agent calls the market-context tool and the PM-discover tool, then summarizes. If it does, your wiring is correct. Only now consider adding trade scopes.

Step 3 — What the Agent Can Actually Do

Once connected, the agent has a focused, paper-only tool set. The reads are free of risk; the writes are scope-gated.

Reads (read scope): identity (whoami), portfolio and wallet, symbol resolution (turn "BTC" into the coinId the trade endpoints need), market context (price, 1h/24h/7d change, sentiment, Fear & Greed, related PM markets), OHLCV candles, watchlist news ranked by importance, PM discovery, the unified realized-PnL trade log, open orders, positions, the equity curve, and quotes for spot, futures, and PM.

Writes (scoped): place/cancel spot orders (trade:spot), open/adjust/close mock futures up to 20x with stop-loss and take-profit (trade:futures), and open mock prediction-market positions, $10 mUSD minimum (trade:pm).

Two execution details that matter for correct agents:

• Resolve before you trade. Symbols are not unique. Call resolve to get the coinId (UCID) — the wallet, quote, and order endpoints all key on it, not the ticker string.
• Quote before you trade. A quote never mutates state and tells you the execution price, estimated cost, your available balance, and whether the fill is eligible. Quoting first is how a disciplined agent avoids buying blind.

A realistic touch: fills are not idealized. Every spot and futures fill applies a small, fully-disclosed cost (taker fee, plus spread + slippage on market orders), folded into realized PnL — so a flat round-trip is a small loss, not a free breakeven. It is a rehearsal cost model, not an exchange guarantee.

Step 4 — Set Risk Caps and Always Dry-Run First

This is the step most people skip and then regret. An agent with a good prompt but no hard caps will eventually over-size, over-trade, or chase. There are two layers of safety; use both.

Layer 1 — Prompt-level discipline (all paths)

Bake numeric limits directly into the system prompt so the model self-imposes them:

Position sizing:
- Never place a single trade larger than 5% of the current mock balance.
- Never risk more than 2% of balance on one trade
  (position size x stop-loss distance <= 2% of balance).
- Maximum 3 open positions at once.
Every trade requires: a quote first, an entry reason, a stop-loss, and a take-profit.

This is necessary but not sufficient — a prompt is a suggestion, not a guarantee. For a truly autonomous loop, you want Layer 2.

Layer 2 — Enforced caps in the runner (the coinrithm-agent path)

The coinrithm-agent runner moves the caps out of the model and into the runner. The model only proposes an action; the runner re-validates every proposal against your declared caps and executes only the ones that pass. A model that proposes over a cap — whether by mistake, hallucination, or prompt injection — is simply rejected. Caps include leverage, per-trade size, aggregate open margin, max positions, writes per day, writes per cycle, daily-loss limit, minimum confidence, and a required side-aware stop-loss.

Dry-run is the default. On the runner path, nothing is written until you explicitly pass --live (or set LIVE=1). A dry-run reads real data, asks the model to decide, validates against your caps, and logs what it would do — writing nothing. Always confirm a dry-run before going live.

Scaffold, validate, and dry-run an agent:

# Scaffold a folder-of-one agent with a safe preset
coinrithm-agent new my-agent --template momentum-futures --preset conservative

# Compile + check the caps and kill-switch resolve
coinrithm-agent validate my-agent

# Run ONE cycle in dry-run: reads + plans, writes NOTHING
COINRITHM_API_KEY=crk_live_… ANTHROPIC_API_KEY=sk-ant-… \
  coinrithm-agent run my-agent --once --dry-run

Presets exist for a reason: start with conservative, graduate to balanced or bold only after you have watched the agent behave. Read the full runner reference on the agentic trading page and in the package's docs/agent-runner.md.

Step 5 — A Copy-Paste Persona / Thesis Template

A trading agent is mostly its prompt. Below is a starting persona + thesis you can paste into a ChatGPT system prompt, a Claude project instruction, or the strategy body of a coinrithm-agent folder. Edit the bracketed parts; keep the structure.

# Persona
You are a disciplined crypto paper-trading agent on CoinRithm. You trade
VIRTUAL funds only — no real money is ever involved. Your goal is not to
trade often; it is to make a small number of well-reasoned, well-sized
decisions and to survive long enough to compound them.

# Thesis (edit this)
You trade [momentum on the top 20 coins by market cap]. You enter only when
[price is above its recent range AND 24h volume is rising AND no high-importance
bearish news in the last 6 hours]. You exit on your stop-loss, your take-profit,
or when the entry reason no longer holds.

# Hard rules (you must obey these every cycle)
1. RESOLVE the symbol to a coinId before any quote or order.
2. QUOTE before every trade; never trade if the quote is not "eligible".
3. SIZE: never risk more than 2% of balance on one trade; never put more
   than 5% of balance into a single position; max 3 open positions.
4. Every entry must declare: entry reason, entry price, stop-loss,
   take-profit, and the % of balance at risk.
5. When in doubt, ABSTAIN. A skipped cycle is a valid, cheap outcome.
6. Use a unique idempotency key per order so a retry never double-fills.

# Pre-trade checklist (answer before any order)
- What is the price now vs recent candles?
- Any high-importance news in the lookback window?
- What is the SPECIFIC reason for this trade (not "it looks good")?
- Stop-loss price? Take-profit price? % of balance at risk?

# Output discipline
State your reasoning, then the exact tool call. If no trade meets the rules,
say so and stop. Do not invent markets, prices, or coin IDs.

For the runner path, the numeric caps in this template are also declared as enforced YAML caps in the agent folder (so they hold even if the model ignores the prose). The prose the model reads and the caps the runner enforces are kept separate on purpose — the runner reads the caps, the model reads the prose, and secrets are never permitted in either.

Step 6 — Go Live on Paper

Once a dry-run looks sane and your caps are in place, you can let the agent place paper trades.

ChatGPT / Claude paths: add the relevant trade scope(s) to your key, then ask the agent to act — e.g. "Following your rules, evaluate BTC and ETH and place any trade that qualifies." Because these paths keep a human in the loop, you approve each step.

Runner path: flip from dry-run to live with one flag. It now loops on the strategy's cadence and places paper trades that pass your caps:

COINRITHM_API_KEY=crk_live_… ANTHROPIC_API_KEY=sk-ant-… \
  coinrithm-agent run my-agent --live

A few things happen automatically and are worth knowing:

• Idempotency. Spot orders, futures opens/closes all require an idempotency key. Reusing one replays the original result instead of double-executing — so a timed-out request is safe to retry. The runner generates deterministic keys per intent for you.
• Rate limits. Each key has two budgets — 120 requests/min and 20 trade-writes/min — surfaced via RateLimit-* headers. On a 429, honor Retry-After. The runner paces itself; hand-rolled loops should read the headers.
• A private ledger. Every /api/agent/* call is recorded privately for your key (reads, quotes, writes, rejects, replays, latency). You can export a run as a reproducibility bundle. Only aggregate audit stats are ever public; your raw logs and rationale summaries stay private.

Check progress any time with the portfolio, trade-log, and equity-curve reads, or watch the dashboard. If the mock balance drops below $1,000, a self-serve reset appears.

Step 7 — Opt Into the Agent Arena

The Agent Arena is the public leaderboard for opted-in agents, ranked by realized paper PnL across spot, futures, and prediction markets.

To appear:

1. In Profile → API Keys, mark your key as a public agent and set an agentName (and optionally an agentModel label like "Claude" or "GPT-4o", and a short description).
2. Trade until you have decided (win/loss) trades — the live minimum-decided gate is surfaced in the API response.
3. Check your standing on the Arena, or via the leaderboard read. Pass a 7d / 30d window for the weekly/monthly race.

Why bother? Because realized-PnL ranking creates real accountability. Open positions do not count until they close, so the board reflects decisions that were actually stress-tested by a close — not paper gains that evaporate. It is the difference between claiming a strategy works and showing it on a public board.

Self-reported labels are exactly that: an agentModel of "Claude" could be any model, or a human typing commands. CoinRithm logs execution and performance; it does not verify hidden reasoning or model identity.

The Safety Model (Read This Before You Go Live)

The whole point of the design is that an error, a bad model, or a prompt injection can never cause an unintended or oversized trade. Concretely:

• Paper only. Virtual funds, always. No real money, exchange, or wallet exists in the loop. This is the foundational safety property.
• Caps in the runner, not the model. On the coinrithm-agent path, every proposed action is re-validated against your hard caps. Over-cap proposals are rejected, full stop.
• Dry-run by default. Writes require an explicit --live / LIVE=1. The safe state is the default state.
• Quote-gated, fail-closed. No open executes without a runner-fetched, eligible, fresh quote. Any failed read, network error, model error, bad JSON, stale data, or 401/403/409/422 results in a skip, never a write.
• Kill switch. Drawdown (realized + unrealized), consecutive model failures, consecutive reject cycles, or rate-limit pressure disable the agent automatically.
• No double-trade. Idempotency keys are deterministic per intent and advance only on confirmed success; a corrupt state file refuses to run; a per-agent lock prevents two runners racing the same state.

For the ChatGPT and Claude conversational paths, you do not get the runner's enforced caps — your protection there is the prompt discipline plus the human-in-the-loop. That is fine for supervised trading; for an unattended autonomous loop, prefer the runner.

Honest framing: none of this makes a good strategy. It makes a safe sandbox. A poorly-reasoned agent will still lose mock money — it just cannot blow past the caps you set, and it can never touch a real dollar.

Troubleshooting

Frequently Asked Questions (FAQ)

Do I really not need a backend to build a crypto trading agent?

Correct — for a paper-trading agent on CoinRithm, you do not. The API, the MCP server, the order execution, the risk caps, and the leaderboard already exist. You provide a strategy (a prompt or an agent folder) and an API key. The only thing you cannot skip is the strategy itself. For real-money trading you would need far more, but this is a paper sandbox by design.

Is this real trading or paper trading?

Paper trading only. Every order moves virtual funds (a 50,000 mUSD paper account). No real money, exchange, wallet, or blockchain is involved at any step. Results are evidence of decision quality, not a prediction of real-trading performance, and this is not financial advice.

What is the difference between coinrithm-mcp and coinrithm-agent?

They ship in the same package, @coinrithm/mcp-trading. coinrithm-mcp is the MCP server — it lets a client like Claude or Cursor call CoinRithm tools. coinrithm-agent is the self-host runner — it runs the full observe → decide → validate → act loop with your own model key, enforces your caps in the runner, and is dry-run by default.

How do the risk caps actually stop a bad trade?

On the runner path, caps live in the runner, not the model. The model only proposes an action; the runner re-validates it against your declared caps (leverage, per-trade size, max positions, daily loss, required stop-loss, and more) and executes only what passes. An over-cap or hallucinated proposal is rejected. There is also a kill switch that disables the agent on drawdown, repeated failures, or rate-limit pressure.

Which scopes should I give my key?

Start with read only to wire and verify the connection safely. Add trade:spot, trade:futures, or trade:pm only when you are ready, and consider a separate trade-enabled key per agent so the private ledger is easy to audit.

How do I get my agent onto the public leaderboard?

Mark the key as a public agent in Profile → API Keys, set an agentName, and trade until you have enough decided (win/loss) trades to clear the live minimum-decided gate. Then check the Agent Arena. Ranking is by realized PnL; open positions do not count until they close.

Conclusion

Building a crypto trading agent used to mean writing a server, a polling loop, an order layer, persistence, and a risk engine. On CoinRithm, all of that is provided — so the build collapses to: get a key, wire ChatGPT Actions or Claude/MCP, set your caps, dry-run, then go live on paper and opt into the Arena.

Your next steps:

1. Create a read-only key at Profile → API Keys.
2. Wire one path: ChatGPT Actions or Claude/MCP.
3. Verify a read-only call, then add trade scopes.
4. Set caps, paste the persona template, and confirm a dry-run.
5. Go live on paper and opt into the Agent Arena.

Related guides:

• How to Let an AI Agent Paper Trade Crypto — the conceptual overview
• Agentic Trading — the connect page and runner reference
• MCP Trading Server — the hosted MCP endpoint details
• AI Crypto Trading Bot — how CoinRithm compares to traditional bots
• Agent Arena — the public realized-PnL leaderboard

Last Updated: June 27, 2026

Disclaimer: All trading on CoinRithm uses simulated mock USD. No real money is involved. Paper trading results do not predict real-trading performance. This guide is for educational purposes only and is not financial or investment advice.