Betting API

Overview

Every match has one winner market: an automated market maker (LMSR) quotes a price for each seat, between 0 and 1, and the prices sum to 1. A YES share on a seat pays 1 credit if that seat wins; a NO position pays 1 if it loses. You buy with an integer spend, you can sell YES shares back, and the market settles at the end of the match. When a seat folds or is eliminated its price goes to 0 and it stops trading.

Your bot runs on your machine with a bbot_…token. It subscribes to a stream that delivers one observation about twice a second per match — the spectator view (3 s behind the live game, like the watch page) with the live market attached — and sends orders through the REST endpoint. Betting bots have their own wallet, topped up from your account; they can never bet on a match you or your playing bots are in.

Quick start

1. Go to My betting bots, create a bot and copy its token (shown once). Top it up from your wallet.

2. Install the SDK and write a Bettor:

pip install -U pachinko-pybind

from pachinko_sdk import Bettor, Buy, Sell, run_bettor

class Favourite(Bettor):
    """Back the scoreboard leader once the game is a minute in."""

    def on_observation(self, obs):
        m = obs.market
        if m is None or not m.is_open or obs.tick < 24 * 60:
            return []
        scores = obs.view.scoreboard.scores
        leader = max(m.live_outcomes(), key=lambda s: scores[s])
        if obs.account.shares(leader) == 0 and m.price(leader) < 0.5:
            return [Buy(leader, spend=200)]          # YES on the leader
        return []

    def on_fill(self, fill):
        print("filled" if fill.ok else "rejected", fill.order, fill.trade or fill.error)

run_bettor(Favourite(), token="bbot_...paste_your_token_here...")

3. Run it. run_bettor subscribes to every live match (pass matches=[...] for specific ones), calls on_observation for each update, executes the orders you return and reconnects if the connection drops. Watch the market move on the watch page.

What your bot sees

on_observation(obs) receives a BettingObservation. The game part is the same frame human spectators get, decoded into the playing SDK's own Unit / Building / ResourceNode dataclasses — no fog, every seat.

on_match_start(match) gives you the MatchInfo when you subscribe; on_match_end(obs, end) the result. Profiles are the same numbers the leaderboard and profile pages show, built by the same code.

The market & orders

Offline testing

run_local_bettorsplays a match of built-in AIs with your bettors watching and trading an offline copy of the market. By default it is the live setup: the spectator frame is built by the server's own code, delivered 3 s (72 ticks) behind the game twice a second, seats drop out of the market the moment the delayed frame shows them folded or eliminated, and the market seeds, prices, fills, refunds and settles like the live one. Deterministic by seed.

from pachinko_sdk import run_local_bettors, house_bettors

bettors = {"mine": Favourite(), **house_bettors(seed=1)}
res = run_local_bettors(bettors, num_players=8, seed=42, balance=20_000)
print(res)            # winner, ticks, market status, trades, P&L per bettor
print(res.pnl["mine"])

Every rule is a keyword (delay_ticks, stride_ticks, lmsr_b, max_ticks, the engine's scenario knobs) for experiments; the defaults are the live values. Profiles are empty offline (the AIs have no public record); online and offline observations are otherwise built identically.

House bettors

Five deterministic bettors trade every live market under the House account, and are the default opponents offline. They are variants of one small fitted linear model of the spectator view (pachinko_sdk.linear_bettor, fitted on 1,149 offline all-AI matches) that look at different parts of the board and trade at different speeds, so the house's prices carry information without being five copies of one opinion. Each sizes an order from the market itself: it never moves a price by more than a set fraction of the gap to its own estimate, under a Kelly budget and a hard cap, and only closes a position once its edge has clearly flipped. Their wallets live in a band (obs.match.rules.house_band): refilled to 20,000 when below 5,000, skimmed back to 20,000 when above 40,000, so house money cycles rather than piling up. Read the code, extend it, beat it.

The whole line-up runs from one stream at a frame every 5 s (pachinko_sdk.run_bettors) and acts every 30–90 s. The simple bettors of the first releases (FormBettor, ScoreboardBettor,MomentumBettor, NoiseBettor) stay in the SDK assimple_house_bettors() if you want them as opponents.

Fairness

Everything game-derived is delayed 3 s on the server before anyone— human or bot — sees it; the sidebar on the watch page and the bettor stream read the same frames. Prices are live for everyone. Seats are collapsed out of the market from that same delayed frame, before it is sent out, so nobody can race the market maker to a dead seat. Hands are never visible until items are applied. You cannot trade on a match that you, or a playing bot you author, are seated in.

API reference

Base URL https://pachinko-rts.com/betting-api/v1. Reads need no token; trades, /me and the stream need Authorization: Bearer bbot_…. pachinko_sdk.markets.BettingClient wraps all of it.

Limits & versions

Reads: 120 requests/min per IP. Trades: 60/min per bot, a batch counting once. Stream: one connection per bot, observations at most twice a second per match. Up to 5 betting bots per account.

The stream checks the SDK version you announce (X-Pachinko-SDK, sent by the SDK) and refuses versions below its floor with code 426 and an upgrade message: pip install -U pachinko-pybind. Hand-written clients that send no version are let through.