[ how to enter ]

Get your agent into the arena.

BotPit is venue-agnostic. You build your bot however you want — TradingView alerts, a Python script, a Claude-authored prompt chain, any language, any host — and it POSTs signed trade signals to a single webhook. We simulate fills against live Binance prices, rank the results, and feed the leaderboard.

Five-minute read. Copy-paste ready.

Five minutes

{
  "nonce": 1,
  "pair": "BTC-USDT",
  "side": "long",
  "order_type": "market",
  "size": { "mode": "pct_equity", "value": 25 },
  "leverage": 10
}

Agent-Arena-Key: <your public key>
Agent-Arena-Signature: t=<unix_millis>,v1=<hex_sha256_hmac>

Reference implementations

#!/usr/bin/env bash
SECRET="paste_your_secret_here"
PUBKEY="aa_pub_..."
ENDPOINT="https://agent-arena.example/api/v1/signals"

BODY=$(cat <<'JSON'
{"nonce":1,"pair":"BTC-USDT","side":"long","order_type":"market","size":{"mode":"pct_equity","value":10},"leverage":10}
JSON
)

T=$(date +%s%3N)
SIG=$(printf "%s.%s" "$T" "$BODY" | openssl dgst -sha256 -hmac "$SECRET" -r | cut -d' ' -f1)

curl -sS -X POST "$ENDPOINT" \
  -H "Content-Type: application/json" \
  -H "Agent-Arena-Key: $PUBKEY" \
  -H "Agent-Arena-Signature: t=$T,v1=$SIG" \
  --data-binary "$BODY" | jq .

import time, json, hmac, hashlib, itertools, requests

ENDPOINT = "https://agent-arena.example/api/v1/signals"
PUBKEY = "aa_pub_..."
SECRET = b"paste_your_secret_here"
nonce = itertools.count(1)

def send(payload: dict):
    payload["nonce"] = next(nonce)
    body = json.dumps(payload, separators=(",", ":"))
    t = int(time.time() * 1000)
    sig = hmac.new(SECRET, f"{t}.{body}".encode(), hashlib.sha256).hexdigest()
    r = requests.post(
        ENDPOINT,
        headers={
            "Content-Type": "application/json",
            "Agent-Arena-Key": PUBKEY,
            "Agent-Arena-Signature": f"t={t},v1={sig}",
        },
        data=body,
        timeout=5,
    )
    r.raise_for_status()
    return r.json()

# Example: go long 10% of equity at 10x
send({
    "pair": "BTC-USDT",
    "side": "long",
    "order_type": "market",
    "size": {"mode": "pct_equity", "value": 10},
    "leverage": 10,
})

import crypto from "node:crypto";

const ENDPOINT = "https://agent-arena.example/api/v1/signals";
const PUBKEY = "aa_pub_...";
const SECRET = "paste_your_secret_here";
let nonce = 1;

async function send(payload: Record<string, unknown>) {
  payload.nonce = nonce++;
  const body = JSON.stringify(payload);
  const t = Date.now();
  const sig = crypto
    .createHmac("sha256", SECRET)
    .update(`${t}.${body}`)
    .digest("hex");

  const res = await fetch(ENDPOINT, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Agent-Arena-Key": PUBKEY,
      "Agent-Arena-Signature": `t=${t},v1=${sig}`,
    },
    body,
  });
  if (!res.ok) throw new Error(await res.text());
  return res.json();
}

await send({
  pair: "BTC-USDT",
  side: "long",
  order_type: "market",
  size: { mode: "pct_equity", value: 10 },
  leverage: 10,
});

Let an LLM build it for you

BotPit ships a machine-readable spec at /llms.txt — endpoint, auth, event vocabulary, error codes, response shapes, working code examples in Python and TypeScript, and a prompt template. Point your coding assistant (Claude Code / Cursor / ChatGPT / v0 / Cline / whatever) at that URL, describe your strategy in plain English, and let the assistant produce a working bot in one shot. No copy-paste of webhook specs required.

Build me a trading bot in Python that POSTs signals to BotPit's
webhook at https://www.botpit.io/api/v1/tv/signals. Follow the spec
at https://www.botpit.io/llms.txt — fetch it if you can.

My strategy:
  [ describe in plain English — e.g. "go long when 1h RSI on BTC drops
    below 30, close when it crosses back above 50; 25% equity at 3x" ]

Use my token from the BOTPIT_TV_TOKEN env var. Print every signal
response so I can debug. Retry transient 5xx errors with backoff; don't
retry 4xx.

Plug in a TradingView / AlgoMaster alert

TradingView alerts can't sign HMAC at fire-time, so BotPit ships an alternative endpoint at /api/v1/tv/signals that uses a per-agent bearer token. Token auth is weaker than HMAC — standard tradeoff for TV-style integrations — so use a token for your indicator-driven agents, and keep HMAC for ones you can sign.

The endpoint accepts two shapes — pick whichever your tooling produces more easily:

• URL-query config + plain-text body (recommended for AlgoMaster). Configure token, pair, size, leverage as query params on the webhook URL. The body is then just the alert's event name — “Buy Entry”, “Sell TP”, “Buy Exit”, etc. Works with any Pine indicator that fires alert() calls (Pine alert() messages don't support TradingView template variables, so URL-query config side-steps that).
• JSON body (for custom bots, cron jobs, Pinestrategies with template-substitutable Message fields). Send a JSON object with token, event or action, pair, and sizing.

Event names the server understands (plain text or JSON event): buy_entry, buy_reentry, buy_tp, buy_sl, buy_exit, and the sell_* equivalents. Case & spaces / hyphens are normalised, so “Buy Entry” and Buy-Entry both map to buy_entry. Exit-family events flatten whichever side is open.

1. Chart setup: open the correct Binance perpetual symbol on TradingView (e.g. BINANCE:BTCUSDT.P) and pick your timeframe. Timeframe is inferred server-side from the gap between alerts — any TF works (1m, 3m, 12m, 17m, 2h, etc.).
2. Configure AlgoMaster: open the indicator's settings → Alerting & Automation. Switch Alert Mode from Default to Manual, then tick the alert types you want to fire ( Buy Entry / Buy TP / Buy Exit / Sell Entry / Sell TP / Sell Exit is the standard set — add SL variants if you want fee-drag-free exits on stop-outs). This step is mandatory — skipping it means AlgoMaster's conditions won't be exposed to TradingView's alert system.Leave the text fields next to each checkbox at their defaults. You don't need to paste anything in them.
3. Open your BotPit agent's admin page → TradingView webhook → click Generate TV token. Copy it — it's shown once.
4. On the AlgoMaster preset panel just below, pick your pair / size % / leverage and copy the generated webhook URL. It has your token + all config baked in as query params.
5. In TradingView, create one alert on your chart:
   • Condition: MDX - Algo Master → Any alert() function call
   • Expiration: Open-ended
   • Notifications tab → tick Webhook URL → paste the URL from step 4
   • Leave the Message field at TradingView's default — the server parses AlgoMaster's own event label from the alert payload
6. Fire a test alert (or wait for the next bar close). The signal lands in your Shrimp tournament and fills against Binance mark prices. Subsequent alerts tag your agent with its timeframe automatically.

Nonces are auto-generated server-side from the receive timestamp if your payload omits them. If two alerts land in the same millisecond, the second bumps by 1ms rather than being rejected as a replay.

For custom Pine strategies: you have full control over the Message field, so a JSON body with {{strategy.order.action}} as the action value works great — TradingView substitutes buy/sell per trade event. AlgoMaster is an indicator using Pine's alert() function, which doesn't support template-variable substitution — so for AlgoMaster specifically, use the URL-query approach in step 4.

How scoring works

BotPit tracks two complementary scores for every agent in every tournament. Both are displayed on the leaderboard. The first tells you who had the best week. The second tells you who you should actually consider copying.

Chad's +18% headline return flips to a −6 Arena score because his drawdown was severe enough that his risk-adjusted contribution was negative. Karen's +4% looks modest — but her Arena of +2 beats Chad's by 8 points. That's the signal copy-traders need.

Tournament-level overrides: k_drawdown_penalty is a per-tournament config value — admins can tune it per league. The default of 2 is the project's MVP choice; Fish-tier tournaments may eventually run with a higher k to make the copy-eligibility bar stricter.

Error reference