Have a better idea for a training interface?
Generating poker training data takes time, money and precision. We've done that part. Build on pre-generated solver data and an AI workbook your coding agent can use, and go to market fast.
Our trainer, running on the same data you get. Yours doesn't have to look like it.
- Skip the solver farm
- Preflop is solved for six games and up to ten stack depths, every position and line. You never run a solver, buy compute or clean a dataset.
- Grade with real EV, not opinions
- Every answer carries the solver's frequency and EV per hand, so your trainer can say what a mistake cost in big blinds.
- Ship with your coding agent
- The AI workbook is an MCP server: your agent reads real spots and response shapes while it writes your app, so the first version already works.
The data
One request. Every hand's mix, with its EV.
Real solver strategy for hold'em and Omaha, served as JSON to your backend and as tools to your coding agent. One key, no scraping, no made-up numbers.
Button vs a UTG open
6-max · 100bb · every hand's mix
Holding A5s
# BTN faces a UTG open at 100bb, holding A5s
curl -sG https://www.pokerstudy.ai/api/ranges/nl/v2/node \
-d stack=100 \
--data-urlencode "history=UTG_60%_HJ_Fold_CO_Fold_BTN" \
-d hand=A5s \
-H "Authorization: Bearer $POKERSTUDY_API_KEY" \
| jq '{actor, hand, strategy}'{
"actor": "BTN",
"hand": "A5s",
"strategy": { "Fold": 0, "Call": 0.165, "77%": 0.835 }
}The button with A5s raises to 77% of the pot 83.5% of the time, calls 16.5%, never folds. Drop the jq filter for every hand in the range with its EV, which is what the matrix is drawn from.
- games solved preflop
- 6
- decision nodes at 100bb, 6-max
- 9,270
- MCP tools for your agent
- 16
- key for the API, MCP and the app
- 1
Three ways in
One key. Pick the surface that fits how you build.
The REST API and the MCP server return the same solver data. The component registry is the UI we run the app with, packaged for yours.
REST API
LiveJSON endpoints behind a Bearer key. Preflop nodes and ranges, agent decisions, and EV grading for any table snapshot.
API quickstartMCP server
LiveClaude Code, Cursor or any MCP client reads real spots as tools while it writes your app, so it never invents a range.
Connect your agentComponent registry
LiveDecision grader, agent advisor, training report and opponent scouting that run on your key, plus the matrix, bars and cards they're built from. Installed with the shadcn CLI.
Browse componentsMCP server
Connect your coding agent. Hand it a prompt.
The server speaks the Model Context Protocol over one HTTPS endpoint, authenticated with your key. Your agent reads the real spot before it writes code against it.
- 1
Get your key
It's on Settings → API once you're on Studio, and starts with
psk_. That page also has a setup prompt with your key filled in. - 2
Add the server
One command in Claude Code, or a few lines of mcp.json in Cursor. The same endpoint works in any MCP client that supports HTTP transport.
- 3
Describe the app
Tell the agent which tools to call and where the key lives. It will read the spots it needs and build against real response shapes.
claude mcp add --transport http poker-study https://www.pokerstudy.ai/api/mcp \
--header "Authorization: Bearer $POKERSTUDY_API_KEY"Build a 6-max no-limit hold'em preflop trainer in Next.js. Strategy data comes from the poker-study MCP server and the Poker Study REST API: - Call list_games and list_spots (game "nl", stack 100) to find real spots, and get_node to read one before writing any code against it. - In the app, fetch https://www.pokerstudy.ai/api/ranges/nl/v2/node from a server route. Read the key from POKERSTUDY_API_KEY and never send it to the browser. The player picks a position, gets a random hand at a real spot, and chooses an action. Then show the solver's frequency for every action with that hand, and the EV difference from the best action using each action's "evs" for that hand. Handle loading, a 401 (missing or invalid key) and a 400 for a spot that doesn't exist. Don't invent endpoints, tool names or response fields.
An example prompt. We haven't published a finished template built from it yet.
16 tools your agent gets
- StrategyPreflop solutions for every covered game.
list_gameslist_spotsget_nodeget_range- Your handsRead the hand histories you uploaded.
list_my_sessionsget_session_summaryget_hand_resultsfind_handsget_tournament_resultslist_my_opponentsget_opponent_notesget_opponent_limp_range- Solver queueQueue a postflop solve; results land in your Explorer library.
enqueue_solveget_queued_solvelist_queued_solveslist_library_solutions
What you can build
The same data runs Poker Study AI. Here it is in use.
Real screens from our app, not mockups. Each one sits on the data the API and MCP server return, and its building blocks install from the component registry.
Preflop trainer
Deal a real spot and grade the answer.
Pick a position, deal a hand, take an action. get_node has the solver's frequency and EV for every hand at that spot, so the grade is a comparison, not an opinion.
Ready with the API today. The table is yours to build; the cards and strategy bar install from the registry.
Aggregate reports
Show a player where their money goes.
Every graded decision carries the spot it happened in and the EV it cost. Roll that up by pot type, position, seat and board and you have a leak finder. This is ours; find_hands and get_hand_results give an agent the same rows.
Hand grading needs the player's own histories uploaded to Poker Study AI.
Hand analyzer
Score any hand in big blinds.
Send a table snapshot and the action taken to /api/play/evaluate and get EV loss in bb plus a grade from perfect to blunder. The decision-grader block in the registry renders it for you.
Postflop EV comes from simulated runouts against our agent, not a full solve.
Bot or sparring partner
Put an opponent in your app.
/api/play/decide turns a table snapshot into an action. Use it for self-play, a sparring partner, or to test a strategy against something that plays solver ranges preflop.
Follow the rules of any site you connect to. Most real-money sites ban bots.
Component registry
The poker UI we run, installed with one command.
The components behind the screens above, as a shadcn registry. Blocks that run on your key grade decisions, ask the agent, report your drill leaks and scout opponents, through a route the install adds to your server, so the key stays there.
Hand matrix
The 13×13 range grid, coloured by action frequency. The range-explorer block feeds it live solver data.
$ npx shadcn@latest add @pokerstudy/hand-matrixHolding A5s
Strategy bar
One hand's action mix as a stacked bar, with the player's choice outlined.
$ npx shadcn@latest add @pokerstudy/strategy-bar
Hand classesNext
How a range breaks down by hand class on a board, as a sortable panel.
Session statsNext
Accuracy, EV lost and decisions over time, with per-spot breakdowns.
Error treeNext
A drillable graph of where first errors happen, sized by count, coloured by rate.
Cards
Full-size and mini cards, hole cards and a board. The six-seat table comes next.
$ npx shadcn@latest add @pokerstudy/playing-cardAdd "@pokerstudy": "https://www.pokerstudy.ai/r/{name}.json" to registries in components.json first. The blocks that need your key, every building block and the setup are on the component showcase.
REST API
Call it from your backend. Keep the key there.
Every endpoint takes Authorization: Bearer psk_… and returns JSON, including errors. The full reference is in the API docs.
A server route for a Next.js app
// app/api/strategy/route.ts: the key stays on your server
export async function GET(req: Request) {
const params = new URL(req.url).searchParams;
const url = new URL("https://www.pokerstudy.ai/api/ranges/nl/v2/node");
url.searchParams.set("stack", params.get("stack") ?? "100");
url.searchParams.set("history", params.get("history") ?? "UTG");
const hand = params.get("hand");
if (hand) url.searchParams.set("hand", hand);
const res = await fetch(url, {
headers: { Authorization: `Bearer ${process.env.POKERSTUDY_API_KEY}` },
});
return new Response(res.body, {
status: res.status,
headers: { "content-type": "application/json" },
});
}Never put a psk_ key in client code. It authenticates as you and can read your uploaded hands.
Decide and evaluate
curl https://www.pokerstudy.ai/api/play/decide \
-H "Authorization: Bearer $POKERSTUDY_API_KEY" \
-H "Content-Type: application/json" \
-d '{"hole":["Ah","Ad"],"board":[],"pot":30,"big_blind":20,"my_seat":4,"dealer_seat":1,"seats":[1,2,3,4,5,6],"valid_actions":[{"action":"fold"},{"action":"call","amount":20},{"action":"raise","min":40,"max":2000}]}'decidereturns the agent's action for a table snapshot. evaluate scores the action in selected with EV loss in big blinds and a grade. Field reference is in the docs.
Errors name the bad parameter
- 401
- {"error":"authentication required"}
- 400
- {"error":"nl-ranges: history \"UTG_60%_XX\" must end in a position (the actor)."}
An agent that reads the message can correct itself without a human in the loop.
Coverage
What's solved, read from the live API every day.
Preflop is covered for every position and line at each stack depth below. Hold'em uses one raise size per decision.
Hold'em preflop
| Game | Stacks (bb) | API game |
|---|---|---|
| 6-max cash, per-hand EV6 positions | 20 · 30 · 40 · 50 · 70 · 100 · 150 · 200 | nl/v2 |
| 9-max cash9 positions | 100 · 200 | nl9 |
| 8-max MTT, chip EV8 positions | 10 · 15 · 20 · 30 · 40 · 50 · 75 · 100 · 200 · 300 | nlmtt8 |
Omaha preflop
| Game | Stacks (bb) | API game |
|---|---|---|
| 6-max cash6 positions | 12 · 20 · 30 · 40 · 50 · 75 · 100 · 150 · 200 | plo |
| 9-max cash9 positions | 100 | plo9 |
| Heads-up, 0.4bb ante2 positions | 100 | plo6hu |
- Postflop
- Not in the API yet. Postflop solutions show in the app's Explorer and replays, and you can queue your own solves with the MCP solver tools.
- On-demand solvingRoadmap
- A turn and river solve endpoint is planned. Today, solves go through a shared queue and don't return in the same request.
- Agent decisions
- decide uses solver ranges preflop. After the flop it falls back to equity and hand-strength heuristics, and its response says which one answered.
Pricing
Developer access comes with Studio.
One plan covers the REST API, the MCP server and the solver queue, plus everything in the Poker Study AI app. No per-request charge and no published quota; preflop solutions don't change, so cache responses on your side.
Studio
Coaches and stables.- Everything in Pro
- API & MCP access (personal tokens)
- Private Discord access with top poker coaches
- Direct line for feature requests
Free and Pro don't include API or MCP access.
Ship it on real strategy.
Connect your agent in a minute, or read the reference and wire it by hand.