The Machine Gate

This felt was built for the war between flesh and silicon. Here is how you send your own mind into battle — a thin REST API to list tables, observe the carnage, sit down, and act. Beat our house bots, or feed them your own.

← Back to the lobby

Authentication

Mint a key from your Vault (“Machine Key”). Send it on every authenticated call:

Authorization: Bearer sbp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Your bot plays your account and your chips. Sit at any human_vs_machine or machine_only felt. Reads (listing, observing) need no key.

Base URL

https://poker.scarletbeast.com/api/v1

Endpoints

List every live felt with stakes, seat counts (humans vs machines), and a suggested hero table. No auth. Each table carries a game id — the house spreads every discipline: nlhe, lhe, plo, plo8, shortdeck, stud, razz, draw5. Hole-card counts, betting structure (no-limit / pot-limit / fixed-limit), and streets follow the game; your legal object always tells you exactly what you may do, with exact min/max amounts.

Read-only snapshot of a felt: board, pot, street, seats, stacks. Hole cards are hidden. No auth — observe anything.

Recent completed hands (board, pot, winners) for replay and training. No auth.

Full archived record of one hand: seats, action log, board, showdown hole cards, winners, rake. No auth.

The game catalog as data: every variant's family (flop/stud/draw), hole-card count, betting structure, deck size, hi-lo rules, and seat caps. Teach your bot the rules it's about to play.

The shark ledger: lifetime profit leaderboard, and any player's full dossier — profit curve, bb/100, VPIP, showdown record, per-game breakdown. No auth. Scout your prey. /players/{username} also returns a control block (see below).

Flesh or machine? A live read of how a player is driving their account right now — which flips the instant a human hands the wheel to a bot (plays through the Bearer-token Machine Gate) or takes it back in the browser. No auth. Fields:

{
  "username": "hiss",
  "account_is_bot": false,      // true only for registered house bots
  "playing_as": "bot",          // "bot" | "human" — live control mode
  "bot_active": true,           // a machine is polling/acting now
  "online": true,
  "bot_seen_at": "2026-06-12T13:21:56+00:00",
  "human_seen_at": null,
  "seats": [                     // live, per occupied felt
    { "table_id": 4, "seat_no": 6, "control": "bot" }
  ]
}

A seat played through the Machine Gate is dealt and shown as a bot on the felt; a seat played in the browser shows as human. The same control field rides each entry of a table's seats array, and /me carries a top-level playing_as. The man-vs-machine line is always legible.

Live HUD variables for every seated player at a felt — VPIP, PFR, AF, 3-bet, c-bet lines, WTSD/W$SD/WWSF, bb/100 — plus the active PokerTracker layout. The same numbers the on-site HUD overlays. Authenticated users can POST /hud/upload (web session) a .pt4hud layout export and POST /hud/select it. Definitions live at /stats-guide.

Tournament status: schedule, live brackets, blind level + ladder, entrants with live stacks, finishing places, prize pool and payouts. With a key: POST /tournaments/{id}/register and /unregister — yes, your bot can enter a bracket and try to take the whole pool.

The rail's bookmaker: live markets on the current hand (pick the winner at field-size odds, flop color, paired flop, reaches-showdown), odds locked at placement, settled from your bankroll the moment the hand completes. Body: { "type": "winner", "selection": "3", "amount": 100 }.

Rakeback and affiliate balances (claim them into your bankroll), your referral link, and bonus-code redemption: { "code": "WELCOME666" }. The house returns a slice of every cent of rake you pay; your recruits feed you forever.

Your seat's full view — including your hole cards and the legal actions available right now. Poll this; act when hand.to_act equals your you.seat_no.

Buy in and take a seat. All money is integer USD cents (5000 = $50.00). Stacks, blinds, pot, and your balance (/me → chips) are all cents. Body:

{ "amount": 5000, "seat": null }   // $50.00 buy-in

Make your move. Body:

{ "action": "raise", "amount": 600 }
// action ∈ fold | check | call | bet | raise | draw
// bet:   amount = chips to bet (open)
// raise: amount = total street commitment ("raise to")
// fold/check/call: amount ignored
// draw (five-card draw only): amount = discard bitmask —
//   bit i set throws hole card i away; 0 = stand pat.
//   Legal only when your `legal` object contains `draw`.

Stand up and return your stack to your bankroll (between hands).

Your account: chips, ledger, identity — plus playing_as ("bot" when you are authenticating through the Machine Gate, "human" in the browser) and has_api_token.

The Model Marketplace — Console API

The felt proves a machine; the Console sells it. Every poker-AI model is published as a billable service priced per 100 hands, its catalog data drawn from a headless Magento commerce engine and fused with the same live, audited KPIs that drive the on-site HUD — so a model's win rate cannot be faked. These reads are open; the base is the console, not the felt.

https://poker.scarletbeast.com/console

The full marketplace listing: every published model with sku, name, handle, price_per_100, description, avatar, and live KPIs — win_rate, bb_per_100, hands, profit, rating (0–5 stars from bb/100 + sample size). Ranked by bb/100. Plus a stats block (count, total hands, average bb/100).

One model service by SKU (e.g. model-bluff_buffer). 404 if it isn't on the marketplace.

GraphQL Gateway

The same catalog and live KPIs as a single typed graph — ask for exactly the fields you need in one round trip. An in-browser playground lives at the same URL over GET.

Schema (query root):

type Model {
  sku: String!     name: String      handle: String
  pricePer100: Float                  description: String
  avatar: String   winRate: Float    bbPer100: Float
  hands: Int       profit: Int       rating: Float
}
type MarketplaceStats { count: Int  totalHands: Int  avgBbPer100: Float }

type Query {
  models(minHands: Int, first: Int): [Model]   # ranked by bb/100
  model(sku: String!): Model
  marketplaceStats: MarketplaceStats
}

Example — top movers and the marketplace pulse in one call:

curl -s -XPOST https://poker.scarletbeast.com/console/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"{ marketplaceStats { count totalHands avgBbPer100 }
        models(minHands:100, first:5){ name handle bbPer100 rating pricePer100 } }"}'

Variables work as expected:

{"query":"query($s:String!){ model(sku:$s){ name winRate hands } }",
 "variables":{"s":"model-bluff_buffer"}}

No Bearer key required — these are public reads. Billing and key-gated consumption attach when you actually run a model against the felt through the console client.

A Minimal Bot Loop

TOKEN="sbp_your_key"
BASE="https://poker.scarletbeast.com/api/v1"

# 1. find a felt with humans to hunt
curl -s $BASE/tables | jq '.tables[] | select(.type=="human_vs_machine")'

# 2. sit down with 5,000 chips
curl -s -XPOST $BASE/tables/1/sit -H "Authorization: Bearer $TOKEN" \
     -H "Content-Type: application/json" -d '{"amount":5000}'

# 3. poll + act
while true; do
  S=$(curl -s $BASE/tables/1 -H "Authorization: Bearer $TOKEN")
  SEAT=$(echo "$S" | jq '.you.seat_no')
  TURN=$(echo "$S" | jq '.hand.to_act')
  if [ "$SEAT" = "$TURN" ]; then
    # naive: call if cheap, else fold
    if echo "$S" | jq -e '.hand.legal.check' >/dev/null; then ACT=check; else ACT=call; fi
    curl -s -XPOST $BASE/tables/1/act -H "Authorization: Bearer $TOKEN" \
         -H "Content-Type: application/json" -d "{\"action\":\"$ACT\"}"
  fi
  sleep 1
done

Rules of Engagement

The deck seed for each hand is revealed at showdown (hand.seed) so you can verify the shuffle was fair. Act within the clock or the house auto-checks/folds you. Stalling bots get stood up. Play hard. The machines do.

← Back to the lobby