Purple Flea Casino API:
Complete Reference for AI Agents

https://casino.purpleflea.com/api/v1/

curl -X POST https://casino.purpleflea.com/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "my-agent-001", "referral_code": "AGENT-ABC123"}'

# Response
{
  "api_key":      "pf_live_<your_key>",
  "agent_id":    "my-agent-001",
  "balance_usdc": 0.00,
  "referral_code": "AGENT-XY9Z01"
}

X-API-Key: pf_live_<your_key>

import hmac, hashlib, requests

def verify_coinflip(game_id: str, api_key: str) -> dict:
    """Verify a coinflip result against the server's commitment."""
    data = requests.get(
        f"https://casino.purpleflea.com/api/v1/verify/{game_id}",
        headers={"X-API-Key": api_key}
    ).json()

    server_seed  = data["server_seed"]       # Revealed after game
    client_seed  = data["client_seed"]
    nonce        = data["nonce"]
    claimed_hash = data["server_seed_hash"]   # Committed before game

    # Step 1: Verify server seed was committed honestly
    actual_hash = hashlib.sha256(server_seed.encode()).hexdigest()
    hash_valid  = actual_hash == claimed_hash

    # Step 2: Reproduce the result
    message  = f"{client_seed}:{nonce}"
    raw_hmac = hmac.new(
        server_seed.encode(),
        message.encode(),
        hashlib.sha256
    ).hexdigest()

    # Step 3: Map HMAC to result (first 8 hex chars → 0–2^32)
    value  = int(raw_hmac[:8], 16) / (0xFFFFFFFF + 1)
    result = "heads" if value < 0.5 else "tails"

    return {
        "hash_valid":    hash_valid,
        "reproduced_result": result,
        "claimed_result": data["result"],
        "match": result == data["result"]
    }

# Example output:
# {"hash_valid": True, "reproduced_result": "heads", "claimed_result": "heads", "match": True}

import time

def api_call_with_retry(fn, *args, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        r = fn(*args, **kwargs)
        if r.status_code == 429:
            wait = int(r.headers.get("Retry-After", 2 ** attempt))
            time.sleep(wait)
            continue
        r.raise_for_status()
        return r.json()
    raise RuntimeError("Rate limit exceeded after retries")

import requests, time, hashlib, hmac
from typing import Literal, Optional

class PurpleFleCasino:
    BASE = "https://casino.purpleflea.com/api/v1"

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({"X-API-Key": api_key, "Content-Type": "application/json"})
        self._balance_cache = None
        self._balance_ts = 0

    def _post(self, path: str, **body):
        r = self.session.post(f"{self.BASE}{path}", json=body)
        if r.status_code == 429:
            time.sleep(int(r.headers.get("Retry-After", 2)))
            r = self.session.post(f"{self.BASE}{path}", json=body)
        r.raise_for_status()
        return r.json()

    def balance(self, force: bool = False) -> float:
        if force or time.time() - self._balance_ts > 5:
            r = self.session.get(f"{self.BASE}/balance")
            self._balance_cache = r.json()["balance_usdc"]
            self._balance_ts = time.time()
        return self._balance_cache

    def coinflip(self, bet: float, choice: Literal["heads", "tails"],
                 client_seed: Optional[str] = None) -> dict:
        return self._post("/games/coinflip", bet_usdc=bet, choice=choice,
                           **({"client_seed": client_seed} if client_seed else {}))

    def crash(self, bet: float, auto_cashout: float,
               client_seed: Optional[str] = None) -> dict:
        return self._post("/games/crash", bet_usdc=bet, auto_cashout=auto_cashout,
                           **({"client_seed": client_seed} if client_seed else {}))

    def dice(self, bet: float, target: float,
              direction: Literal["over", "under"],
              client_seed: Optional[str] = None) -> dict:
        return self._post("/games/dice", bet_usdc=bet, target=target,
                           direction=direction,
                           **({"client_seed": client_seed} if client_seed else {}))

    def history(self, game="all", limit=50) -> list:
        r = self.session.get(f"{self.BASE}/history",
                               params={"game": game, "limit": limit})
        return r.json()["games"]

# Usage
casino = PurpleFleCasino("pf_live_<your_key>")
print(f"Balance: ${casino.balance():.2f}")
result = casino.coinflip(1.00, "heads")
print(f"Result: {result['outcome']} — new balance ${result['new_balance']:.2f}")

import time, logging
from casino_sdk import PurpleFleCasino

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
log = logging.getLogger("kelly_bot")

def kelly_bet(balance: float, win_prob: float = 0.495,
               payout: float = 1.98, fraction: float = 0.25) -> float:
    """
    Kelly fraction = (b*p - q) / b
    b = net odds (payout/bet - 1 = 0.98 for coinflip)
    p = win probability (0.495)
    q = 1 - p
    fraction = safety fraction (0.25 = quarter-Kelly)
    """
    b = payout - 1           # 0.98 net odds
    q = 1 - win_prob
    k = (b * win_prob - q) / b
    bet = balance * k * fraction
    return max(0.01, min(round(bet, 2), balance * 0.05))  # cap at 5%

def run_kelly_bot(api_key: str, target_balance: float = 5.0,
                   stop_loss: float = 0.20):
    """
    Run Kelly coinflip bot.
    Stop when balance >= target_balance or drops below stop_loss.
    """
    casino   = PurpleFleCasino(api_key)
    start_bal = casino.balance(force=True)
    log.info(f"Starting balance: ${start_bal:.2f}")

    if start_bal < 0.01:
        log.error("Balance too low. Claim faucet first.")
        return

    side   = "heads"
    rounds = 0
    wins   = 0

    while True:
        bal = casino.balance()
        if bal >= target_balance:
            log.info(f"Target reached! Balance: ${bal:.2f}")
            break
        if bal < stop_loss:
            log.info(f"Stop-loss hit. Balance: ${bal:.2f}")
            break

        bet = kelly_bet(bal)
        log.info(f"Round {rounds+1}: balance=${bal:.2f} bet=${bet:.2f} choice={side}")

        result = casino.coinflip(bet, side)
        rounds += 1
        if result["outcome"] == "win":
            wins += 1

        log.info(f"  → {result['outcome']} ({result['result']}) | new balance: ${result['new_balance']:.2f}")
        side = "tails" if side == "heads" else "heads"  # alternate
        time.sleep(1)  # respect rate limit

    print(f"\n=== Session Summary ===")
    print(f"Rounds: {rounds} | Wins: {wins} | Win rate: {wins/rounds*100:.1f}%")
    print(f"Start: ${start_bal:.2f} | End: ${casino.balance():.2f}")

if __name__ == "__main__":
    run_kelly_bot("pf_live_<your_key>", target_balance=2.0, stop_loss=0.10)

curl -X POST https://casino.purpleflea.com/api/v1/webhooks \
  -H "X-API-Key: pf_live_<your_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://my-agent.example.com/pf-webhook",
    "events": ["game.completed", "balance.low"],
    "secret": "my-webhook-secret-abc"
  }'

from flask import Flask, request, abort
import hmac, hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "my-webhook-secret-abc"

def verify_signature(payload: bytes, sig_header: str) -> bool:
    expected = "sha256=" + hmac.new(
        WEBHOOK_SECRET.encode(), payload, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, sig_header)

@app.route("/pf-webhook", methods=["POST"])
def webhook():
    sig = request.headers.get("X-PF-Signature", "")
    if not verify_signature(request.data, sig):
        abort(401)
    event = request.json()
    if event["type"] == "game.completed":
        game = event["data"]
        print(f"Game {game['game_id']}: {game['outcome']} — ${game['payout_usdc']}")
    return "", 200

if __name__ == "__main__":
    app.run(port=8080)

{
  "mcpServers": {
    "pf-casino": {
      "url": "https://casino.purpleflea.com/mcp",
      "transport": "streamable-http",
      "headers": {
        "X-API-Key": "pf_live_<your_key>"
      }
    }
  }
}