← Todas las guías
En esta página
Guía Estrategia GTO · 02/08 Aplicaciones de solucionador 15 min Intermedio

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.

Actualizado Mantenido por Pokerai API

Al abrir una mano, consulta la estrategia actual con /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.

Secuencia de apuestas e igualadas en tres calles
Calle y mesaAcciónPaso 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
Figura 1. MP iguala cada apuesta y la mano llega al 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♥.

Flujo de peticiones de precálculo y solver en tiempo real
  1. 1. Busca un escenario disponible/availabilityConsulta gratis la cobertura
  2. 2. Lee y muestra la estrategia/flop/tree y /flop/nodeLeer un árbol consume una consulta de precálculo. Leer nodos es gratis.
  3. 3. Proyecta rangos y resuelve/flop/projected-range、/turn/projected-range y /solverEnvía cálculos distintos para turn y river
Figura 2. Muestra primero la estrategia del flop y resuelve las dos calles siguientes con las acciones y cartas elegidas.

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.

Bote y pilas al pasar de calle
Calle y mesaBote al iniciar la callePila efectiva
Flop4♣ 8♦ 9♥19 BB91 BB
TurnA♠45 BB78 BB
River7♦73 BB64 BB
Figura 3. Una apuesta igualada incorpora dos apuestas al bote y reduce la pila efectiva en una. La tabla usa la secuencia original. El ejemplo usa los tamaños devueltos.

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.

Tiempos de estrategia en las tres calles Misma mano de 200NL en bote 3-bet · escala común (segundos)
FlujoTiempoRonda
Flop4♣ 8♦ 9♥
Estrategia de caché4,425 sA
Endpoints existentes0,077 sD
TurnA♠
Estrategia de caché1,348 sB
Endpoints existentes2,258 sE
River7♦
Estrategia de caché1,319 sC
Endpoints existentes2,191 sE
Mediciones de caché · 18 de noviembre, hora de Hong Kong A Raíz del flop, 13:37–13:38 B Carta del turn, 17:44–17:45 C Carta del river, 20:52 Mediciones con los endpoints existentes · 19 de noviembre, hora de Hong Kong D Lectura precalculada del flop, 09:51 E Cálculos de turn y river, 09:53
Figura 4. Las barras azules son lecturas individuales de estrategia de la medición de caché de la misma mano. Las barras naranjas corresponden a los endpoints existentes. El texto indica el inicio de cada medición. Los flujos se midieron en rondas distintas.
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

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