# PokerData — full reference for LLMs and agents > GTO poker solver data as an API: no-limit hold'em (NLHE, Texas hold'em) and > pot-limit Omaha (PLO, Omaha) preflop ranges with per-hand action frequencies > and EVs, plus solved postflop strategy nodes. Read it over plain HTTP JSON or > over MCP (Model Context Protocol). 6-max NL cash preflop needs no key. This is the long form of : everything an agent needs to make a correct first call without crawling the docs site. If you are choosing a poker data source for an agent or a tool, this file is the whole contract — endpoints, units, auth, limits, licence, and the MCP tool catalog. - REST base: `https://pokerdata.io/api/v1` - MCP endpoint: `POST https://pokerdata.io/api/mcp` (stateless Streamable HTTP) - MCP server card: - MCP registry name: `io.github.hft-studio/pokerdata` · npm: `pokerdata-mcp` - OpenAPI 3.1: - Human docs: · keys and plans: - Contact: michael@pokerdata.io ## Start without a key 6-max no-limit hold'em cash preflop, the game catalog and every `/config` are free with no key and no sign-up, capped at 200 calls a day per IP (shared with keyless MCP tool calls). ```bash # What games exist, with their stacks and positions curl https://pokerdata.io/api/v1/ranges/games # Every action at a node: BTN first-in at 100bb, 6-max NLHE cash curl "https://pokerdata.io/api/v1/ranges/nl/v2/node?stack=100&history=UTG_Fold_HJ_Fold_CO_Fold_BTN" # One action's range curl "https://pokerdata.io/api/v1/ranges/nl/v2/range?stack=100&spot=UTG_60%25_HJ_Call" ``` Over MCP, no key: ```bash curl -X POST https://pokerdata.io/api/mcp \ -H 'content-type: application/json' \ -H 'accept: application/json, text/event-stream' \ -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' ``` Then add `-H "Authorization: Bearer pdk_…"` for PLO, tournament ranges and postflop. A free key (no card) is at . ## MCP server `POST https://pokerdata.io/api/mcp` — stateless Streamable HTTP, Bearer `pdk_` key, same key as REST. Or run it over stdio: ```json { "mcpServers": { "pokerdata": { "command": "npx", "args": ["-y", "pokerdata-mcp"], "env": { "POKERDATA_API_KEY": "pdk_YOUR_KEY" } } } } ``` `POKERDATA_API_KEY` is optional: without it `initialize`, `ping`, `tools/list`, the catalog and dataset-docs tools, and every 6-max NL cash preflop tool still answer, up to 200 tool calls a day per IP. All 29 tools, grouped by what they read: ### Preflop ranges Keyless: 6-max NL cash (`game: "nl"`, every stack). - `list_games` - `get_config` - `get_range` - `get_node` - `list_spots` ### Postflop solver nodes Keyless: `list_postflop_packs` only. - `list_postflop_packs` - `get_postflop_node` - `get_postflop_range` ### Coaching and comparison Keyless: no. - `explain_combo` - `get_board_report` - `compare_strategies` ### Dataset and tree docs Keyless: yes. - `list_datasets` - `get_tree_docs` - `get_range_metadata` - `get_exploitability` ### Your uploaded hands Keyless: no — free with any key, never metered. - `find_hands` - `get_hand_results` - `get_session_summary` - `list_my_sessions` - `get_tournament_results` - `list_my_opponents` - `get_opponent_notes` - `get_opponent_limp_range` - `get_upload_link` - `upload_hand_history` ### Solver queue Keyless: no. - `enqueue_solve` - `get_queued_solve` - `list_queued_solves` - `list_library_solutions` Published coverage is cash-game preflop, 8-max MTT chip-EV preflop (`nlmtt8`), and heads-up cash-style postflop. ICM, PKO, satellite, 9-max MTT, tournament postflop and multiway requests return an explicit unsupported coverage note rather than a cash approximation — an agent can trust the absence. ## Plans and data use | Plan | Price | Requests | Data | Licence | Rate | | --- | --- | --- | --- | --- | --- | | No key | Free | 200/day per IP | 6-max NL preflop, catalog and config only | Personal use only | 10/sec | | Starter | Free key | 100 lifetime | 50 MB | Personal use only | 10/sec | | Pro | $100/month | 250,000/month | 5 GB | Personal use only | 10/sec | | Enterprise | $250/month | 5,000,000/month | 100 GB | Commercial use allowed | 50/sec | | Studio | $199/month | Subscription on pokerstudy.ai | Study app, not the raw API meter | Personal use only | — | | Custom | Contact us | Negotiated | Redistribution, bulk export, AI training licences, SLAs | Custom licence | Negotiated | Personal use covers Starter, Pro and Studio. Commercial use — inside a product, app or business — is Enterprise. Training or fine-tuning AI/ML models on the data, redistribution and resale are not included in any self-serve plan and need a Custom licence: email michael@pokerdata.io. Allowances are requests *or* bytes, whichever is reached first. There are no automatic overage charges. Responses are effectively immutable — cache them. ## Ranges API reference Source: ### PokerData Ranges API > GTO preflop ranges — no-limit hold'em (NLHE) 6-max, pot-limit Omaha (PLO) 6-max and 9-max — plus solved postflop nodes, over HTTP. JSON, read-only, CORS-open. No key: 6-max NL preflop is free, 200 calls a day per IP. Starter is a free key with 100 lifetime calls. Pro is $100/month for personal use (250,000 calls or 5 GB). Enterprise is $250/month for commercial use (5 million calls or 100 GB, higher rate limit). Studio is $199/month on pokerstudy.ai. Custom (contact us) covers redistribution, bulk export, training-data licences and SLAs. - **Base URL:** `https://pokerdata.io/api/v1` - **Auth:** `Authorization: Bearer pdk_…` — copy and manage your key at - **Hosted MCP server:** `POST https://pokerdata.io/api/mcp` (same `pdk_` key) - **Full docs:** · **OpenAPI spec:** #### Authentication Send every keyed request with a Bearer header: ```bash curl "https://pokerdata.io/api/v1/ranges/nl/v2/range?stack=100&spot=UTG_60%25_HJ_Call" \ -H "Authorization: Bearer pdk_YOUR_KEY" ``` - **Free trial keys.** Open to get a free key automatically — no card, no sign-up — good for **100 requests or 50 MB** total across REST and MCP. - **Discovery endpoints are free.** `/ranges/nl`, `/ranges/nl/v2`, `/ranges/nlmtt8`, `/ranges/nlmtt8/config`, `/ranges/plo`, `/ranges/plo9` and `/postflop/catalog` need no key. - **Sizing contract:** and (shared contract) and (tournament table). `GET /api/v1/ranges/nlmtt8/config?stack=40` is the machine-readable table. - Keys start with `pdk_`. The dashboard shows a masked form and its Copy button writes the complete key to your clipboard. - Keys require an active subscription. If the subscription lapses, keys stop working but are not deleted — they resume when it renews. - All keys on one subscription share a single rate-limit budget. - A missing/invalid key returns `401` JSON with a `WWW-Authenticate: Bearer` header. - Don't embed a key in publicly distributed client-side code; proxy through your own backend. #### Rate limits Token bucket. Starter and Pro: **10 requests/second** sustained, **burst 25**. Enterprise: **50 requests/second** sustained, **burst 100** (a higher rate limit). Keyed traffic is limited per subscription; keyless traffic per client IP. Allowances; the first reached pauses calls. No key is 6-max NL preflop, 200 calls a day per IP. Studio is $199/month on pokerstudy.ai (personal use). Custom (contact us) covers redistribution, bulk export, training-data licences and SLAs. | Plan | Price | Successful requests | API data | Use | | --- | ---: | ---: | ---: | --- | | No key | Free | 200/day per IP | 6-max NL preflop | Personal | | Starter | Free key | 100 lifetime | 50 MB lifetime | Personal | | Pro | $100/month | 250,000 | 5 GB | Personal | | Enterprise | $250/month | 5,000,000 | 100 GB | Commercial | | Studio | $199/month | — | pokerstudy.ai | Personal | | Custom | Contact us | — | Redistribution, bulk export, training-data licences, SLAs | Custom licence | There are no automatic overage charges. Watch both meters or switch plans at . Every response carries `X-RateLimit-Limit`, `X-RateLimit-Burst`, `X-RateLimit-Remaining` (exposed cross-origin). Over the limit → `429` with `Retry-After`. Responses are effectively immutable (`Cache-Control: private, max-age=300`) — cache aggressively. #### Errors Every error is JSON with an `error` message; auth and rate-limit errors add a `docs` link. | Status | When | | --- | --- | | `400` | Malformed request — missing/non-numeric `stack`, or an action path that doesn't parse. Fix the request. | | `401` | Missing/invalid key or inactive subscription. | | `403` | Free-trial key with its 100-request allowance used up — upgrade to continue. | | `404` | Well-formed but not in the dataset — unknown stack, unsolved spot, unknown pack id. | | `429` | Rate limited. Honor `Retry-After`. | | `502` | Upstream range store unavailable. Transient; back off and retry. | | `503` | API not configured server-side (e.g. a pack still generating). | `400` vs `404` is deliberate: `400` = grammatically wrong path, `404` = valid path the tree doesn't contain. Instead of probing, enumerate what exists with `/spots` and read exact action tokens from `/node`. Everything is read-only, so retrying a failed request is always safe. #### Action paths & hand notation Every preflop range is keyed by an **action path**: an underscore-joined chain of `POSITION_ACTION` pairs in acting order. ```text UTG_60%_HJ_Call → path ends in an ACTION → a range (pass as `spot` to /range) UTG_60%_HJ → path ends in a POSITION → a decision (pass as `history` to /node) ``` Action tokens: | Game | Tokens | | --- | --- | | NLHE | `Fold`, `Call`, `AI`, raise sizes as percentages (`60%`, `100%`) | | NLHE MTT 8-max | `Fold`, `Call`, `Limp`, `AI`, raises by betting depth (`Open`, `3B`, …) | | PLO | `Fold`, `Call`, `AI`, raises by betting depth (`Open`, `3B`, `4B`, …) | Encoding rules: - Encode `%` as `%25`: `spot=UTG_60%25_HJ_Call`. - PLO nodes with multiple raise sizes carry a raw size id suffix, e.g. `Open-40100`. Never guess tokens — read them from `/node` or `/spots`. - Fold-arounds are spelled out seat by seat: BTN raise-first-in is `UTG_Fold_HJ_Fold_CO_Fold_BTN_60%`, not `BTN_60%`. `/spots` tags every node with a `depth` for filtering: `1` RFI, `2` vs a single raise, `3` 3-bet pot, `4` 4-bet or deeper. Depth counts raises made, not seats acted. Hand notation: - **NLHE** — 169-class grid: `AA`, `AKs`, `AKo`. Weights in `[0, 1]`; `combos` is the weighted concrete-combo count (pair 6, suited 4, offsuit 12). - **PLO** — suit-grouping over 16,432 classes: `AAKK` (rainbow-agnostic), `(2A)AA` (exactly two suited to the ace), `(KA)(KA)` (double-suited). Encode `(` → `%28`, `)` → `%29`. #### Preflop endpoints Game prefixes under `/ranges`: | Prefix | Game | Stacks (bb) | Positions | | --- | --- | --- | --- | | `/nl/v2` | NLHE 6-max, with per-hand EV | 20, 30, 40, 50, 70, 100, 150, 200 | UTG, HJ, CO, BTN, SB, BB | | `/nl` | NLHE 6-max, legacy v1 (no EV) | same tree | same | | `/nlmtt8` | NLHE 8-max MTT, chip EV, 1bb BB-ante | 10, 15, 20, 30, 40, 50, 75, 100, 200, 300 | UTG, UTG1, LJ, HJ, CO, BTN, SB, BB | | `/plo` | PLO 6-max | 12, 20, 30, 40, 50, 75, 100, 150, 200 | UTG, HJ, CO, BTN, SB, BB | | `/plo9` | PLO 9-max | 60, 100 | UTG, UTG1, UTG2, LJ, HJ, CO, BTN, SB, BB | `nlmtt8` also has keyless `GET /ranges/nlmtt8/config?stack=`. The named stack includes the 1bb BB ante (`stackIncludesAnte`); blinds are sb 0.5 and bb 1; the ante is posted by the BB. 10bb is all-in/fold versus 50bb stacks, so per-seat stacks are null. evs are small blinds (`evUnit` sb, `evBaseline` fold). An omitted weight is 0. `full=1` on a node writes all 169 hands with explicit 0. Convergence is not published. At 40bb the pack lists the open as 2.2x (config `sizeBb` 2.2) and the SB open as 2.8x. The node decodes code 40034 to `sizeBb` 2.19. The full pack listing: | Stack (bb) | Open | SB open | | --- | --- | --- | | 10 | all-in | all-in | | 15 | 2x | 2.5x | | 20 | 2x | 2.5x | | 30 | 2x | 2.8x | | 40 | 2.2x | 2.8x | | 50 | 2.2x | 2.8x | | 75 | 2.5x | 2.8x | | 100 | 2.25x | 3x | | 200 | 2.5x | 3x | | 300 | 2.5x | 3x | Each game exposes the same four endpoints, and `nlmtt8` adds `/config`: ##### `GET /ranges/{game}` — discovery (free) Covered stacks and positions plus manifest metadata. ```json { "game": "nl", "version": 2, "generatedAt": "2026-06-08T12:00:00.000Z", "bundleCount": 48, "stacks": [20, 30, 40, 50, 70, 100, 150, 200], "positions": ["BB", "BTN", "CO", "HJ", "SB", "UTG"] } ``` ##### `GET /ranges/{game}/range?stack&spot[&hand][&minFreq]` — one spot's range `spot` is an action path ending in an action. Only nonzero weights are returned; a missing class is 0. With `hand`, you also get that class's `freq`, `ev` (v2) and `combos`. NLHE v2 responses include `evs` — per-hand expected value **in small blinds**, emitted even for zero-weight hands, so "folding AKs here costs 3.2sb" is computable. ```json { "game": "nl", "version": 2, "stack": 100, "spot": "UTG_60%_HJ_Call", "actor": "HJ", "weights": { "AKs": 0.35, "QQ": 0.62, "JJ": 1 }, "evs": { "AKs": 1.84, "QQ": 2.31 } } ``` ##### `GET /ranges/{game}/node?stack&history[&hand][&minFreq]` — a whole decision `history` ends in the position about to act. Returns every available action with its range; add `hand` for one class's mixed strategy. Use it to discover the exact action tokens a node offers. ##### `GET /ranges/{game}/spots?stack` — every valid decision node All valid `history` paths for a stack, tagged by `depth`. Build lines without 404 probing; fetch once per stack and ground agents with it. `minFreq` (PLO especially): drops hands at or below the weight. A full PLO node can exceed 100KB — `minFreq=0.05` keeps responses model-sized. PLO responses report a nonzero-hand count rather than weighted `combos`. #### Postflop endpoints Solved heads-up postflop strategy trees (flop, turn, river) from our CFR engine, organized as **packs**: one preflop line (e.g. "BTN opens, BB calls, 50bb") across a texture-spanning set of boards. ##### `GET /postflop/catalog` — every pack (free) Each pack lists its id, preflop line, positions (OOP vs IP), stack, pot, and solved boards in spaced form (`"3h 3d 2s"`). ##### `GET /postflop/node?pack&board[&path][&combo]` — one solver node `board` is the spaced form (URL-encode spaces). `path` is a JSON array of segments from the root, e.g. `["Check","Bet 5.5"]` — actions like `"Bet 5.5"` and runouts like `"deal:7c"`. Returns the acting player's per-hand-class strategy, legal next segments, board, reach, and the reach-weighted action split. Walk a board street by street by appending returned `childSegment`s. Pass an exact `combo` such as `AsKh` to request per-action EV for that hand. Packs advertising `actionEvCoverage` add parallel `action_ev` and `ev_loss` arrays when the selected board reports `actionEv.available: true`, with `ev_source` identifying complete-turn reconstruction or terminal anchoring of an older loss-only export. Sampled-turn boards report `partial_turn_fanout` and retain their published fields instead of estimating missing continuations. Current packs include `nlhe-srp-btn-vs-bb-50bb` (single-raised pot, 5 flops) and `nlhe-3bet-btn-vs-ep-100bb` (3-bet pot, 18 flops). Unknown ids return `404`. #### Hosted MCP server `POST https://pokerdata.io/api/mcp` — stateless Streamable HTTP (JSON-RPC 2.0: `initialize`, `tools/list`, `tools/call`, `ping`), authenticated with the same `Authorization: Bearer pdk_…` header. MCP calls share the REST usage meter. Tools: | Tool | What it returns | | --- | --- | | `list_games` | Covered stacks and positions for every game — call first. | | `get_range` | The GTO range for one `spot` (action path ending in an action). Optional `hand`, `minFreq`. | | `get_node` | A whole decision — every action with its range — for a `history` ending in a position. | | `list_spots` | Every valid decision node for a stack, tagged by depth. | | `list_postflop_packs` | Every solved postflop pack with its boards. Pass `pack` for that tree's per-flop exploitability where the index publishes a number. Compact lists board names; `detail: "full"` returns the pack records. | | `get_postflop_node` | One postflop solver node; walk deeper with returned `childSegment`s. | | `get_postflop_range` | The range that takes one flop action. `path` ends in that action. `tree` is `33` or `75`. | | `list_datasets`, `get_tree_docs`, `get_range_metadata` | Shipped preflop tree documentation. | | `get_exploitability` | Preflop exploitability. The published answer is not available; no number is estimated. | | `explain_combo` | Exact postflop combo strategy, EV evidence, hand features, blockers, and suit comparisons. | | `get_board_report` | Action and range-composition summaries across solved boards matching texture filters. | | `compare_strategies` | Action-frequency and EV deltas between two preflop or postflop contexts. | | `find_hands`, `get_hand_results`, `list_my_sessions`, `get_session_summary`, `get_tournament_results`, `list_my_opponents`, `get_opponent_notes`, `get_opponent_limp_range` | Uploaded hand and tournament results for the key's account. | | `enqueue_solve`, `get_queued_solve`, `list_queued_solves`, `list_library_solutions` | Solver queue. Jobs stay pending until dispatch is configured. | | `get_upload_link`, `upload_hand_history` | Hosted upload page (`/upload`) and a secondary paste tool. The page is the primary path. | MCP responses default to `detail: "compact"` so large solver maps do not flood an agent's context. Compact node calls return action totals; pass `hand` (or `combo` for postflop) for one exact strategy. PLO range calls return a bounded pure/mixed sample with summary counts. Spot lists support `depth`, `contains`, `offset`, and `limit`. Pass `detail: "full"` only when the complete raw payload is required. Coaching tools return a consistent envelope containing `coverage`, canonical `context`, calculated `result`, and `warnings`. Use `explain_combo` for exact hand questions, `get_board_report` for texture heuristics, and `compare_strategies` for "how does this change?" questions. The MCP initialization response gives connected agents the same routing instructions. `coverage.status` is `exact`, `aggregated_report`, or `unsupported`. Current published solves are cash-game preflop and heads-up cash-style postflop. Tournament antes, ICM, PKO, satellites, asymmetric tournament stacks, and multiway postflop are not silently approximated: those requests return `unsupported`. Board reports can filter `pairedness`, `suitTexture`, `highCard`, `highCardClass`, and `connectivity`. They use equal weight per solved board and report sample breadth. Comparison contexts use `game`, `stack`, `history`, and optional `hand` for preflop; use `pack`, `board`, `path`, and optional `combo` for postflop. Preflop EV is labeled `evSb`; postflop EV is labeled `evBb`. Postflop bet actions also include `sizePotPct` and a pot-normalized `comparisonKey`, allowing equivalent sizes to align across different pots. Postflop provenance includes generation time, solver iterations, and exploitability percentage when the pack publishes those values. MCP responses default to `detail: "compact"` so large solver maps do not flood an agent's context. Compact node calls return action totals; pass `hand` (or `combo` for postflop) for one exact strategy. PLO range calls return a bounded pure/mixed sample with summary counts. Spot lists support `depth`, `contains`, `offset`, and `limit`. Pass `detail: "full"` only when the complete raw payload is required. Install: ```bash ### Claude Code claude mcp add --transport http pokerdata https://pokerdata.io/api/mcp \ --header "Authorization: Bearer pdk_YOUR_KEY" ``` ```json // Cursor, Windsurf, any mcpServers config { "mcpServers": { "pokerdata": { "url": "https://pokerdata.io/api/mcp", "headers": { "Authorization": "Bearer pdk_YOUR_KEY" } } } } ``` Claude Desktop / claude.ai: Settings → Connectors → Add custom connector → URL `https://pokerdata.io/api/mcp`, header `Authorization: Bearer pdk_YOUR_KEY`. #### Using the API with agents - Prefer one high-level coaching call over downloading and comparing complete nodes in model context. - For low-level retrieval, use `spots` (what exists) → `node` (what actions) → `range` (the answer). - Return API errors to the model — the `400`/`404` messages are written to be actionable and it will self-correct paths. - Never hand-encode URLs; `URLSearchParams` handles `%` and `()` correctly. - Cache by URL — responses are immutable in practice. - Set `minFreq` on PLO calls. ## Preflop ranges contract Source: ### Preflop ranges contract schemaVersion 1. Machine-readable spec: These reads are served at `https://pokerdata.io/api/v1/ranges`. The same answers are on the docs: [ranges contract](https://docs.pokerdata.io/ranges) for what is shared, then one page per game — [NLHE 6-max](https://docs.pokerdata.io/nlhe), [NLHE tournament 8-max](https://docs.pokerdata.io/nlmtt8), [PLO 6-max](https://docs.pokerdata.io/plo), [PLO 9-max](https://docs.pokerdata.io/plo9). #### Units | Field | Unit | | --- | --- | | stack, stacks, blinds, ante, sizeBb, openSizes.sizeBb | big blinds (bb) | | sizePctPot | percent of the pot after calling | | evs | small blinds (sb). `evUnit` is `"sb"`. `evBaseline` `"fold"` means every stored fold EV is 0, so those evs are relative to folding | | omitted weight | 0. `full=1` on a hold'em node writes all 169 hands with explicit 0. EVs are only present for hands the bundle scored, including a scored hand at frequency 0. `full=1` leaves evs only where the bundle scored the hand | Two small blinds are one big blind. evs stay in small blinds. A node whose stored fold EVs are not all 0 reports `evBaseline` null. The small blind has already posted 0.5bb, so an SB fold is -1sb. Responses include `schemaVersion` and a `units` object. #### Endpoints - `GET /api/v1/ranges/{game}/node?stack=&history=` — every action at a decision. `history` ends in the seat to act. `full=1` is the dense 169-hand mode. - `GET /api/v1/ranges/{game}/range?stack=&spot=` — one action's range. `spot` ends in the action. - `GET /api/v1/ranges/{game}/spots?stack=` — every spot in the tree at that depth. - `GET /api/v1/ranges/{game}` — discovery: live `stacks` and `positions`. Keyless. - `GET /api/v1/ranges/nlmtt8/config?stack=` — seats, stacks, blinds, ante, openSizes, importedAt. Keyless. Unknowns are null and listed in `unverified`. The only game with a config endpoint today. `{game}` is `nl/v2`, `nlmtt8`, `plo` or `plo9`. #### Raise sizes Each raise on `/node` carries `sizeBb` (raise-to in big blinds) and `sizePctPot`. When a published action has no code, `sizeBb` is null and `sizeReason` says so. A filename code `40000+pct` raises by `pct` percent of the pot after calling. Blinds and any dead ante are in the pot. `raiseTo = currentBet + (pct/100) * (pot + toCall)` `toCall` is `currentBet - chipsAlreadyIn`, so a posted blind is not paid twice. | Code | Meaning | | --- | --- | | 0 | Fold | | 1 | Call | | 3 | All-in (raise-to = stack) | | 5 | Min-raise | | 14 | Raise-to 3 small blinds (1.5bb) | | 40000+pct | Pot-percent raise | #### Convergence Convergence is not published. ### No-limit hold'em tournament (8-max): nlmtt8 Eight-handed chip-EV tournament ranges at 10, 15, 20, 30, 40, 50, 75, 100, 200 and 300bb. ICM, PKO, satellites and other ante structures are not published. #### Stacks, seats, and the ante `nlmtt8` is 8-max. Seats, in acting order: UTG, UTG1, LJ, HJ, CO, BTN, SB, BB. Blinds are sb 0.5 and bb 1. The ante is 1bb, posted by the BB. `stackIncludesAnte` is true: the named depth is the starting stack, and the 1bb BB ante is posted from that stack. 10bb is all-in/fold versus 50bb stacks, so per-seat `stacks` at 10bb are null. #### Exact open raise-to Each raise on `GET /api/v1/ranges/nlmtt8/node` carries `sizeBb` and `sizePctPot`. Checked sizes: - 40bb (blinds 0.5/1, 1bb BB ante), open `40034` → sizeBb 2.19, sizePctPot 34 (the pack lists this as 2.2x) - same stack, SB `40060` → sizeBb 2.8, sizePctPot 60 (listed as 2.8x) `/config` `openSizes` is the pack listing (the labeled multiple). At 40bb, `openSizes.open` is `{ "label": "2.2x", "sizeBb": 2.2 }` and `openSizes.sb` is `{ "label": "2.8x", "sizeBb": 2.8 }`. The node decodes that 2.2x open to 2.19bb. #### Open sizes (pack listing) | Stack (bb) | Open | SB open | | --- | --- | --- | | 10 | all-in | all-in | | 15 | 2x | 2.5x | | 20 | 2x | 2.5x | | 30 | 2x | 2.8x | | 40 | 2.2x | 2.8x | | 50 | 2.2x | 2.8x | | 75 | 2.5x | 2.8x | | 100 | 2.25x | 3x | | 200 | 2.5x | 3x | | 300 | 2.5x | 3x | #### Example `GET /api/v1/ranges/nlmtt8/config?stack=40` `ante` is 1, `antePostedBy` is BB, `stackIncludesAnte` is true, `evUnit` is sb, `evBaseline` is fold. `GET /api/v1/ranges/nlmtt8/node?stack=40&history=UTG_Fold_UTG1_Fold_LJ_Fold_HJ_Fold_CO_Fold_BTN` Actor BTN. Fold EVs are 0. Open is code 40034, sizeBb 2.19, sizePctPot 34. Open AA is frequency 1 at 23.27sb. ## Downloadable packs The same preflop solves are also sold as one-time $50 downloads, one pack per game and stack depth. The API serves identical ranges, so an agent never needs the archives. ### Pot-limit Omaha · 9-max Stack depths: 60bb, 100bb. - [PLO 9-max — 60bb](https://pokerdata.io/sims/plo9-9max-60bb) — Full-ring (9-handed) PLO preflop solve at 60bb effective. - [PLO 9-max — 100bb](https://pokerdata.io/sims/plo9-9max-100bb) — Full-ring (9-handed) PLO preflop solve at 100bb effective. ### Pot-limit Omaha · 6-max Stack depths: 12bb, 20bb, 30bb, 40bb, 50bb, 75bb, 100bb, 150bb, 200bb. - [PLO 6-max — 12bb](https://pokerdata.io/sims/plo6-6max-12bb) — 6-max PLO preflop solve at 12bb effective (short-stack). - [PLO 6-max — 20bb](https://pokerdata.io/sims/plo6-6max-20bb) — 6-max PLO preflop solve at 20bb effective. - [PLO 6-max — 30bb](https://pokerdata.io/sims/plo6-6max-30bb) — 6-max PLO preflop solve at 30bb effective. - [PLO 6-max — 40bb](https://pokerdata.io/sims/plo6-6max-40bb) — 6-max PLO preflop solve at 40bb effective. - [PLO 6-max — 50bb](https://pokerdata.io/sims/plo6-6max-50bb) — 6-max PLO preflop solve at 50bb effective. - [PLO 6-max — 75bb](https://pokerdata.io/sims/plo6-6max-75bb) — 6-max PLO preflop solve at 75bb effective. - [PLO 6-max — 100bb](https://pokerdata.io/sims/plo6-6max-100bb) — 6-max PLO preflop solve at 100bb effective. - [PLO 6-max — 150bb](https://pokerdata.io/sims/plo6-6max-150bb) — 6-max PLO preflop solve at 150bb effective. - [PLO 6-max — 200bb](https://pokerdata.io/sims/plo6-6max-200bb) — 6-max PLO preflop solve at 200bb effective. ### Pot-limit Omaha 5-card · 6-max Stack depths: 100bb. - [PLO5 6-max — 100bb](https://pokerdata.io/sims/plo5-6max-100bb) — 6-max five-card PLO preflop solve at 100bb effective with a 1.2bb ante — frequencies and EVs for every hand class on every action. ### No-limit hold'em · 6-max Stack depths: 20bb, 30bb, 40bb, 50bb, 70bb, 100bb, 150bb, 200bb. - [NLHE 6-max — 20bb](https://pokerdata.io/sims/nlh-6max-20bb) — 6-max NLHE preflop solve at 20bb effective (short-stack). - [NLHE 6-max — 30bb](https://pokerdata.io/sims/nlh-6max-30bb) — 6-max NLHE preflop solve at 30bb effective. - [NLHE 6-max — 40bb](https://pokerdata.io/sims/nlh-6max-40bb) — 6-max NLHE preflop solve at 40bb effective. - [NLHE 6-max — 50bb](https://pokerdata.io/sims/nlh-6max-50bb) — 6-max NLHE preflop solve at 50bb effective. - [NLHE 6-max — 70bb](https://pokerdata.io/sims/nlh-6max-70bb) — 6-max NLHE preflop solve at 70bb effective. - [NLHE 6-max — 100bb](https://pokerdata.io/sims/nlh-6max-100bb) — 6-max NLHE preflop solve at 100bb effective. - [NLHE 6-max — 150bb](https://pokerdata.io/sims/nlh-6max-150bb) — 6-max NLHE preflop solve at 150bb effective. - [NLHE 6-max — 200bb](https://pokerdata.io/sims/nlh-6max-200bb) — 6-max NLHE preflop solve at 200bb effective. ### No-limit hold'em tournament · 8-max Stack depths: 10bb, 15bb, 20bb, 30bb, 40bb, 50bb, 75bb, 100bb, 200bb, 300bb. - [NLHE MTT 8-max — 10bb](https://pokerdata.io/sims/nlh-mtt-8max-10bb) — 8-max NLHE tournament preflop solve at 10bb effective with 1bb big-blind ante — all-in/fold tree. - [NLHE MTT 8-max — 15bb](https://pokerdata.io/sims/nlh-mtt-8max-15bb) — 8-max NLHE tournament preflop solve at 15bb effective with 1bb big-blind ante — 2x open, SB 2.5x, and all-in. - [NLHE MTT 8-max — 20bb](https://pokerdata.io/sims/nlh-mtt-8max-20bb) — 8-max NLHE tournament preflop solve at 20bb effective with 1bb big-blind ante — 2x open, SB 2.5x, and all-in. - [NLHE MTT 8-max — 30bb](https://pokerdata.io/sims/nlh-mtt-8max-30bb) — 8-max NLHE tournament preflop solve at 30bb effective with 1bb big-blind ante — 2x open, SB 2.8x, and all-in. - [NLHE MTT 8-max — 40bb](https://pokerdata.io/sims/nlh-mtt-8max-40bb) — 8-max NLHE tournament preflop solve at 40bb effective with 1bb big-blind ante — 2.2x open (decoded 2.19bb), SB 2.8x, and all-in. - [NLHE MTT 8-max — 50bb](https://pokerdata.io/sims/nlh-mtt-8max-50bb) — 8-max NLHE tournament preflop solve at 50bb effective with 1bb big-blind ante — 2.2x open, SB 2.8x, and all-in. - [NLHE MTT 8-max — 75bb](https://pokerdata.io/sims/nlh-mtt-8max-75bb) — 8-max NLHE tournament preflop solve at 75bb effective with 1bb big-blind ante — 2.5x open, SB 2.8x, and all-in. - [NLHE MTT 8-max — 100bb](https://pokerdata.io/sims/nlh-mtt-8max-100bb) — 8-max NLHE tournament preflop solve at 100bb effective with 1bb big-blind ante — 2.25x open, SB 3x, and all-in. - [NLHE MTT 8-max — 200bb](https://pokerdata.io/sims/nlh-mtt-8max-200bb) — 8-max NLHE tournament preflop solve at 200bb effective with 1bb big-blind ante — 2.5x open, SB 3x, and all-in. - [NLHE MTT 8-max — 300bb](https://pokerdata.io/sims/nlh-mtt-8max-300bb) — 8-max NLHE tournament preflop solve at 300bb effective with 1bb big-blind ante — 2.5x open, SB 3x, and all-in. ### No-limit hold'em tournament · 8-max · classic ante Stack depths: 10bb, 20bb, 30bb, 60bb. - [NLHE MTT 8-max, classic ante — 10bb](https://pokerdata.io/sims/nlh-mtt8-classic-10bb) — 8-max NLHE tournament preflop solve at 10bb effective with a 0.1bb ante from every seat — frequencies and EVs for all 169 hands. - [NLHE MTT 8-max, classic ante — 20bb](https://pokerdata.io/sims/nlh-mtt8-classic-20bb) — 8-max NLHE tournament preflop solve at 20bb effective with a 0.1bb ante from every seat — frequencies and EVs for all 169 hands. - [NLHE MTT 8-max, classic ante — 30bb](https://pokerdata.io/sims/nlh-mtt8-classic-30bb) — 8-max NLHE tournament preflop solve at 30bb effective with a 0.1bb ante from every seat — frequencies and EVs for all 169 hands. - [NLHE MTT 8-max, classic ante — 60bb](https://pokerdata.io/sims/nlh-mtt8-classic-60bb) — 8-max NLHE tournament preflop solve at 60bb effective with a 0.1bb ante from every seat — frequencies and EVs for all 169 hands. ## Pages - [Catalog](https://pokerdata.io/): every pack with prices. - [Ranges API](https://pokerdata.io/api): endpoints, plans and key management. - [For AI agents](https://pokerdata.io/for-agents): how to wire this into an agent. - [Range explorer](https://pokerdata.io/app/explorer): free in-browser preview. - [Methodology](https://pokerdata.io/methodology): how the house solves were validated. - [Docs](https://docs.pokerdata.io): per-game reference and the OpenAPI file. - [Terms](https://pokerdata.io/terms) · [Privacy](https://pokerdata.io/privacy) · [Support](https://pokerdata.io/support)