Crea análisis de póker de baja latencia con los datos precalculados y el solver en tiempo real de PokerAI
Lee la estrategia precalculada del flop de PokerAI y muestra las frecuencias de acción al recibirla. Una mano real de 200NL en un bote 3-bet ilustra cómo encontrar un escenario, cambiar de acción y mesa y llevar ambos rangos al solver en tiempo real en turn y river.
/flop/tree y /flop/node. Muestra las frecuencias cuando llegue la respuesta. Cuando el usuario elija una nueva carta, proyecta ambos rangos según la secuencia de acciones y envía el cálculo de esa calle. Mantén visible la estrategia anterior mientras trabaja el solver.Cuándo combinar datos precalculados y solver en tiempo real
Empieza por la estrategia precalculada del flop y resuelve cada calle posterior cuando haga falta si el directorio de la caché carece de la mano o quieres elegir los rangos o tamaños de apuesta posteriores. El flujo está disponible en Free, Starter, Builder y Pro, con las cuotas de precálculo y resolución de cada plan. Tiene que haber un escenario de flop precalculado disponible.
Proyecta ambos rangos según las acciones reales y resuelve por separado turn y river. El resultado es una aproximación calle por calle al equilibrio de Nash del árbol completo de tres calles. Las estrategias posteriores dependen de los rangos, las pilas, los tamaños permitidos y el cálculo. Muestra primero el flop y añade la estrategia de cada calle cuando llegue.
Datos clave de la mano de 200NL en un bote 3-bet
La mano usa el paquete preflop 6max_RC_100bb_200NL. MP (posición media) abre y SB (ciega pequeña) hace 3-bet. SB tiene A♥K♥ en 4♣8♦9♥. El flop comienza con un bote de 19 BB y 91 BB efectivos.
| Calle y mesa | Acción | Paso siguiente |
|---|---|---|
| Flop4♣ 8♦ 9♥ | SB apuesta 13 BB MP iguala | Sale A♠ |
| TurnA♠ | SB apuesta 14 BB MP iguala | Sale 7♦ |
| River7♦ | SB apuesta 22 BB MP iguala | Showdown |
SB apuesta 13, 14 y 22 BB en las tres calles y MP iguala cada vez. Es la misma mano de la guía de la API Cache. En el ejemplo del solver en tiempo real, SB juega OOP y MP juega IP.
Busca un escenario disponible
Envía el paquete preflop, el flop y la situación a /availability para comprobar si la biblioteca precalculada contiene la mano. La consulta es gratuita con cualquier clave de API válida.
curl 'https://pokerai.bet/v1/gto/availability' \
-H "Authorization: Bearer $POKERAI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"type":"flop","request":{"preflop_pack":"6max_RC_100bb_200NL","board":"4c8d9h","pot_type":"3BET","positions":{"raiser":"MP","three_bettor":"SB","hero":"SB"}}}'
Antes de continuar, comprueba status: "available", match: "exact" y resolved_preflop_pack. Los endpoints de flop existentes pueden recurrir al paquete por defecto si el especificado carece del escenario. Para reproducir la mano, verifica el paquete resuelto antes de permitir un cambio de fuente.
Lee la estrategia del flop
Llama a /flop/tree desde tu servidor y guarda allí la clave de API. Usa el token del nodo raíz en /flop/node con hole_cards: "AhKh" para leer la estrategia de A♥K♥.
- 1. Busca un escenario disponible
/availabilityConsulta gratis la cobertura - 2. Lee y muestra la estrategia
/flop/treey/flop/nodeLeer un árbol consume una consulta de precálculo. Leer nodos es gratis. - 3. Proyecta rangos y resuelve
/flop/projected-range、/turn/projected-rangey/solverEnvía cálculos distintos para turn y river
Esta petición lee la raíz del flop y consume una consulta de precálculo. El ejemplo completo incluye las funciones post y waitForTree.
const spot = {
preflop_pack: "6max_RC_100bb_200NL",
board: "4c8d9h",
pot_type: "3BET",
positions: { hero: "SB", raiser: "MP", three_bettor: "SB" },
};
const hand = "AhKh";
const available = await post("/availability", { type: "flop", request: spot });
if (available.status !== "available" || available.match !== "exact" ||
available.resolved_preflop_pack !== spot.preflop_pack) {
throw new Error("This exact presolved Flop spot is not available.");
}
const flop = await post("/flop/tree", { ...spot, hole_cards: hand });
const root = flop.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!root?.token) throw new Error("The expected SB root is unavailable.");
const flopStrategy = await post("/flop/node", {
node: root.token,
hole_cards: hand,
});
Representa strategy como frecuencias de acción y guarda los tokens devueltos para consultas posteriores. El campo node: "root" de la respuesta puede identificar la ruta. En cada consulta posterior, envía el token correspondiente en node.
Si ya tienes la matriz de estrategia para el rango completo, selecciona la fila correspondiente al cambiar de mano. Vuelve a consultar la estrategia al cambiar el nodo de acción.
Sigue la secuencia hasta el turn y el river
En el flop SB apuesta 13 BB y MP iguala. El turn es A♠. SB apuesta 14 BB, MP vuelve a igualar y el river es 7♦. Incluye la última igualada de cada calle al proyectar los rangos para reflejar qué manos conserva el rival cuando iguala.
| Calle y mesa | Bote al iniciar la calle | Pila efectiva |
|---|---|---|
| Flop4♣ 8♦ 9♥ | 19 BB | 91 BB |
| TurnA♠ | 45 BB | 78 BB |
| River7♦ | 73 BB | 64 BB |
Proyecta ambos rangos después de la igualada del flop
Confirma con /flop/node que el rival puede igualar tras la apuesta. Envía el escenario original y la ruta terminada en /CALL a /flop/projected-range. El endpoint lee los rangos efectivos del árbol precalculado y calcula qué rangos quedan después de la acción.
const action = flopStrategy.strategy.find((row) => row.action === "bet" &&
!row.allin && row.amount_bb === 13);
const afterBet = flop.nodes.find((entry) => entry.node === "root/BET_13" &&
!entry.is_hero);
if (!action || !afterBet?.token) throw new Error("The 13 BB Flop branch is unavailable.");
const opponent = await post("/flop/node", { node: afterBet.token });
if (!opponent.actions?.some((row) => row.action === "call")) {
throw new Error("The Flop call branch is unavailable.");
}
const turnRanges = await post("/flop/projected-range", {
...spot,
node_id: afterBet.node + "/CALL",
normalize: false,
bluff_discount_ratio: 1,
});
Lee las combinaciones ponderadas en range_oop_new_raw y range_ip_new_raw. La proyección usa la mesa de la calle anterior. Antes de enviar el cálculo, elimina todas las combinaciones bloqueadas por la nueva carta y conserva el resto con sus pesos. AhKh solo se indica para mostrar la estrategia. La proyección y el cálculo usan ambos rangos completos. Si llamas a /v1/gto/range y construyes el árbol, parte de ranges.effective del árbol del flop.
Envía el cálculo del turn tras salir A♠
Envía a /solver la mesa de cuatro cartas 4c8d9hAs, los dos rangos sin combinaciones bloqueadas por A♠, el bote y la pila efectiva. El parámetro público de tamaño admite porcentajes enteros del bote. En esta medición, 31 produjo una apuesta de 14 BB en un bote de 45 BB. Usa el tamaño devuelto para continuar.
if (!turnRanges.range_oop_new_raw || !turnRanges.range_ip_new_raw) {
throw new Error("Turn ranges are unavailable.");
}
const turnBoard = ["4c", "8d", "9h", "As"];
const turn = await post("/solver", {
board: turnBoard.join(""),
oop_range: rangeForBoard(turnRanges.range_oop_new_raw, turnBoard),
ip_range: rangeForBoard(turnRanges.range_ip_new_raw, turnBoard),
pot: flop.pot + 2 * action.amount_bb,
effective_stack: flop.effective_stack - action.amount_bb,
hero: "OOP",
bet_sizes: { turn: [31] },
donk_sizes: { turn: [31] },
});
const turnTree = await waitForTree(turn.solve);
const turnRoot = turnTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!turnRoot?.token) throw new Error("The expected Turn root is unavailable.");
const turnStrategy = await post("/solver/node", {
node: turnRoot.token,
hole_cards: hand,
});
if (!Array.isArray(turnStrategy.strategy)) throw new Error("Turn strategy is unavailable.");
Envía el cálculo del river después de la igualada del turn
Llama a /turn/projected-range con el identificador del cálculo del turn y la ruta correspondiente. Los árboles en tiempo real usan rutas como root/BET 14.000000. Añade /CALL a la ruta devuelta. Quita las combinaciones que contienen 7♦ de ambos rangos y envía un nuevo cálculo para 4c8d9hAs7d.
const selected = await selectBetCall(turnTree, turnStrategy, 14);
const riverRanges = await post("/turn/projected-range", {
solve: turn.solve,
node_id: selected.entry.node + "/CALL",
normalize: false,
bluff_discount_ratio: 1,
});
if (!riverRanges.range_oop_new_raw || !riverRanges.range_ip_new_raw) {
throw new Error("River ranges are not ready.");
}
const riverBoard = [...turnBoard, "7d"];
const river = await post("/solver", {
board: riverBoard.join(""),
oop_range: rangeForBoard(riverRanges.range_oop_new_raw, riverBoard),
ip_range: rangeForBoard(riverRanges.range_ip_new_raw, riverBoard),
pot: Number((turnTree.pot + 2 * selected.bb).toFixed(2)),
effective_stack: Number((turnTree.effective_stack - selected.bb).toFixed(2)),
hero: "OOP",
bet_sizes: { river: [30] },
donk_sizes: { river: [30] },
});
const riverTree = await waitForTree(river.solve);
const riverRoot = riverTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!riverRoot?.token) throw new Error("The expected River root is unavailable.");
const riverStrategy = await post("/solver/node", {
node: riverRoot.token,
hole_cards: hand,
});
if (!Array.isArray(riverStrategy.strategy)) throw new Error("River strategy is unavailable.");
const showDown = await selectBetCall(riverTree, riverStrategy, 22);
console.log({ turn: selected.bb, river: showDown.bb });
La apuesta original en el river fue de 22 BB. Los tamaños del ejemplo dieron esa rama en la medición. Muestra el importe y las frecuencias que devuelve el solver. Tras la igualada que lleva al showdown, puedes llamar a /solver/release una vez finalizada la última consulta.
Mantén la estrategia visible mientras se ejecuta el cálculo
Muestra juntos la estrategia y el estado del cálculo. Al seleccionar turn o river, conserva la estrategia anterior mientras se calcula la nueva calle. Consulta /solver/tree con el identificador original hasta recibir spot_status: "queryable" y luego usa el token devuelto en /solver/node.
Deja que el usuario decida cuándo reintentar tras 429 busy. Termina la espera con no_nodes, error o expired. Si vence el tiempo del envío y se desconoce el resultado, conserva la vista para evitar un segundo envío con cargo. Si el usuario cambia la acción o la mesa, ignora las respuestas tardías de la selección anterior según el contexto de la petición.
Tiempos de petición y cuotas
Los 0,077479 s del flop incluyen las lecturas del árbol precalculado y del nodo. Los 2,258036 s del turn se cuentan desde el envío corregido. La proyección previa de rangos del flop llevó 0,079021 s y se midió aparte. Los 2,190538 s del river empiezan al proyectar los rangos del turn e incluyen envío, sondeo y lectura del nodo. Las barras de la caché representan consultas individuales de estrategia para la misma mano.
| Flujo | Tiempo | Ronda | |
|---|---|---|---|
| Flop4♣ 8♦ 9♥ | |||
| Estrategia de caché | 4,425 s | A | |
| Endpoints existentes | 0,077 s | D | |
| TurnA♠ | |||
| Estrategia de caché | 1,348 s | B | |
| Endpoints existentes | 2,258 s | E | |
| River7♦ | |||
| Estrategia de caché | 1,319 s | C | |
| Endpoints existentes | 2,191 s | E | |
| Operación de API | Cuota consumida |
|---|---|
Comprobar el escenario con /availability |
0 |
Leer un árbol precalculado con /flop/tree |
1 consulta de precálculo |
| Leer un nodo ordinario del flop o del solver con un token válido | 0 |
Proyectar ambos rangos del flop con /flop/projected-range |
1 consulta de precálculo |
Iniciar un nuevo cálculo de turn o river con /solver |
1 resolución por cada cálculo nuevo |
Sondear /solver/tree, proyectar rangos del turn o liberar un cálculo |
0 |
El ejemplo consume dos consultas de precálculo y hasta dos resoluciones en las tres calles. Si se devuelve directamente un cálculo idéntico, revisa el comprobante solve_quota. Las consultas de nodos ordinarios y el sondeo reutilizan el token o identificador original.
Ejecuta el ejemplo completo
Conserva juntos las posiciones, las cartas privadas, la mesa y la secuencia de acciones. Muestra la estrategia del flop al cargarla y gestiona la carga y los errores por separado en turn y river. Reutiliza el envío en curso cuando coincidan la mesa, los rangos, el bote, la pila efectiva y los tamaños.
Coloca las funciones auxiliares de abajo antes de los cuatro bloques JavaScript anteriores y ejecútalos como módulo ES de Node.js. Ejecutar el ejemplo contra la API de producción consume la cuota de la cuenta.
const API = "https://pokerai.bet/v1/gto";
const key = process.env.POKERAI_API_KEY;
if (!key) throw new Error("Set POKERAI_API_KEY on your backend.");
async function post(path, body, timeoutMs = 15_000) {
const response = await fetch(API + path, {
method: "POST",
headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
body: JSON.stringify(body),
signal: AbortSignal.timeout(timeoutMs),
});
const payload = await response.json();
if (!response.ok) throw new Error(`${path}: HTTP ${response.status} (${payload.error ?? payload.status ?? "unknown"})`);
return payload;
}
function rangeForBoard(range, board) {
const blocked = new Set(board);
const combos = range.split(",").map((item) => item.trim()).filter((item) => {
const match = /^([2-9TJQKA][cdhs])([2-9TJQKA][cdhs]):([0-9.]+(?:e[+-]?\d+)?)$/i.exec(item);
if (!match || !Number.isFinite(Number(match[3]))) {
throw new Error("Invalid weighted combo in the projected range.");
}
const canonical = (card) => card[0].toUpperCase() + card[1].toLowerCase();
const first = canonical(match[1]);
const second = canonical(match[2]);
if (first === second) throw new Error("Duplicate card in a projected combo.");
return !blocked.has(first) && !blocked.has(second);
});
if (!combos.length) throw new Error("No legal combinations for the next board.");
return combos.join(",");
}
async function selectBetCall(tree, strategy, targetBb) {
const bets = tree.nodes.flatMap((entry) => {
const match = /^root\/BET (\d+(?:\.\d+)?)$/.exec(entry.node);
return match && !entry.is_hero && entry.token ? [{ entry, bb: Number(match[1]) }] : [];
});
const selected = bets.sort((a, b) => Math.abs(a.bb - targetBb) - Math.abs(b.bb - targetBb))[0];
if (!selected || Math.abs(selected.bb - targetBb) > 0.5 ||
!strategy.strategy.some((row) => row.action === "bet" && !row.allin &&
Math.abs(row.amount_bb - selected.bb) < 0.02)) {
throw new Error(`No supported bet sizing close to ${targetBb} BB.`);
}
const opponent = await post("/solver/node", { node: selected.entry.token });
if (!opponent.actions?.some((row) => row.action === "call")) {
throw new Error("The call branch is unavailable.");
}
return selected;
}
async function waitForTree(solve, deadlineMs = 90_000) {
if (typeof solve !== "string" || !solve) throw new Error("Missing solve handle.");
const deadline = Date.now() + deadlineMs;
while (Date.now() < deadline) {
const tree = await post("/solver/tree", { solve }, Math.min(10_000, deadline - Date.now()));
if (tree.spot_status === "queryable") return tree;
if (!["available", "computing"].includes(tree.spot_status)) {
throw new Error(`Solve stopped: ${tree.spot_status ?? "missing status"}`);
}
const delay = Math.min(1_000, deadline - Date.now());
if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
}
throw new Error("Solve polling timed out. Keep the original handle.");
}
Mediciones y reproducción
La mano y su secuencia de acciones proceden de una captura de la API Cache en producción del 18 de noviembre de 2026. Las peticiones HTTPS públicas a los endpoints existentes del 19 de noviembre confirmaron el mismo paquete, la misma mano y las tres apuestas igualadas de 13, 14 y 22 BB. Los dos envíos iniciaron cálculos nuevos. La prueba consumió dos consultas de precálculo y dos resoluciones.
El primer envío del turn devolvió invalid_range y no consumió cuota de resolución. El rango de la calle anterior aún incluía A♠. Tras filtrar las combinaciones bloqueadas como en el ejemplo, la resolución siguió la ruta original. El gráfico distingue las rondas de medición. Las cartas de la mesa y las acciones públicas se mantuvieron al proyectar y filtrar.
Al citar el resultado, incluye el paquete, la mesa, la secuencia de acciones, la fecha y el método de medición. La guía está destinada al entrenamiento, la investigación y la revisión posterior a la sesión. El análisis en tiempo real significa aquí explorar escenarios de forma interactiva. Está prohibida la asistencia en tiempo real en mesas de dinero real.
Documentación de la API · Referencia de la API · Flujo del solver en tiempo real · OpenAPI · llms.txt
Lee las tres calles directamente si el escenario está en la caché completa
Con Builder o Pro y un escenario completamente precalculado en la caché, puedes leer la estrategia del mismo árbol al cambiar la acción o la mesa. La otra guía recorre la misma mano de 200NL en un bote 3-bet, desde la consulta gratuita de cobertura hasta la estrategia en las tres calles y el EV y la equity bajo demanda. Crea un producto de análisis de póker en tiempo real y con baja latencia con la API Cache de PokerAI