PaaS
Closed beta · invite-first · free to start

Poker as a Service

APIs and evidence-backed poker primitives for apps, agents, leagues, creators, and communities. In closed beta now: invited developers create a test key and call the same calculation engines that power the PokerWorks Lab — metered, versioned, and built to grow into hosted social poker infrastructure.

Start building Read the docs
api.pokerworks.io
# calculate a final-table ICM deal
curl https://api.pokerworks.io/v1/calculations/icm/deal \
-H "Authorization: Bearer pw_test_…" \
-d '{"stacks":[420000,280000,160000],
"payouts":[5000,3000,2000]}'
{
"engine": "icm-deal-calculator",
"result": { "icm": [5140, 3210, 1650] },
"usage": { "charged": 2 }
}
Available now

Calculation endpoints, ready first

The lowest-risk way to ship a real developer primitive: deterministic engines, JSON in and out, bounded compute. Each one mirrors a tool you can already try in the Lab.

  • POST /v1/calculations/equity/holdem

    Hold’em equity

    Hand or range equity for heads-up spots — exact enumeration where it’s bounded, seeded Monte Carlo where it isn’t.

  • POST /v1/calculations/icm/deal

    ICM deal

    Final-table deal suggestions from stacks and remaining payouts — ICM, chip-chop, equal, and blended, side by side.

  • POST /v1/calculations/tournaments/payouts

    Tournament payouts

    A publishable payout ladder from field size, prize pool, style, and rounding policy — with reconciliation metadata.

  • POST /v1/calculations/tournaments/blinds

    Blind structures

    Blind levels, antes, and breaks for clubs, home games, and content tools — no runtime tournament authority.

  • POST /v1/calculations/chips/starting-stack

    Chip starting stacks

    A physical chip distribution plan from player count, stack, and denominations — with inventory feasibility.

Beta integrations are cURL/OpenAPI-first today; a typed TypeScript SDK is coming soon as @pokerworks/sdk. The same calculation surface powers our public docs and OpenAPI contract.

For agents

Deterministic poker tools your LLM can call

Language models guess at exact poker math; they don’t compute it. PokerWorks returns exact, versioned results an agent can trust — callable over plain HTTP today, with an MCP server planned so assistants can use the same tools natively.

  • Typed inputs and outputs, easy to wrap as a tool
  • Every result carries its engine version
  • Grounded numbers instead of hallucinated equity
tool call
tool pokerworks.equity.holdem
input A♠A♥ vs K♣K♦
llm “around 70%, I think?”
pokerworks 81.7% · exact · v1
Where this goes

From calculations to hosted poker

Calculation APIs are the wedge, not the destination. The durable platform is hosted social poker infrastructure — the primitives below are direction, not yet available.

We publish developer recipes for concrete outcomes as each primitive becomes safe to package. Some recipes are closed beta or design previews until the public contract is promoted.

  • Hosted tables Planned

    Spin up play-money tables and launch tickets through the API, scoped to your tenant.

  • Embeds Planned

    Drop calculators and live tables into your own content with first-party embeds.

  • Realtime state Planned

    Subscribe to table and hand state over the wire instead of polling.

  • Webhooks Planned

    Receive game lifecycle and result events at your own endpoints.

  • MCP server Planned

    Expose PokerWorks calculations as tools any AI agent or assistant can call natively.

  • Hand history Planned

    Structured, privacy-classified hand histories once consent and ToS posture are settled.

  • Fairness evidence Planned

    Verifiable shuffle and RNG evidence attached to the hands you serve.

How it works

From sign-up to first call

  1. 01

    Create an account

    Sign up in the console with Google or email. Developer Platform is in closed beta — invited developers can create a test key right away.

  2. 02

    Create a key

    Issue a test key yourself in one click. The raw key is shown once; we only ever store its hash.

  3. 03

    Make a first request

    Call a deterministic endpoint — ICM or chip stacks — and get a typed, versioned result back.

  4. 04

    Track usage and go live

    Every request is metered by endpoint and key. Free credits get you started; paid usage is enabled per account as the beta opens up.

Trust & boundaries

Built to be trusted in production

The same posture we hold for the platform: deterministic, versioned, privacy-respecting, and honest about what it is and isn’t.

  • Deterministic engines

    The same tested engines behind the Lab tools. Monte Carlo runs are seeded so results are reproducible.

  • Versioned contracts

    A small public OpenAPI contract — separate from our internal surface — with an engine version on every result.

  • No request-body logging

    Calculations are processed synchronously and not persisted by default. Request bodies are not logged.

  • Bounded compute

    Per-request compute budgets, payload limits, and iteration caps. The API meters or fails closed — never silently.

  • No strategy advice

    Equity and structure math, not “call/fold” advice. No solver or GTO output in the calculation API.

  • Not real-money gambling

    PokerWorks is social, play-money poker. The API is infrastructure for builders — not gambling operations.